feat: add CI testing workflow and Docker test suite

- Add GitHub Actions workflow for running tests
- Add docker-compose test configuration
- Add Python test suite with HTTP stats, MTProto port, and Telethon tests
- Add TESTING.md documentation
- Fix secret generation in Dockerfile (use xxd from vim-common)
- Use non-privileged port 8443 in CI to avoid permission issues

Fixes #21

Author: dvershinin

.github/workflows/test.yml

@@ -0,0 +1,89 @@
+name: CI
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Build and Run Tests
+      env:
+        # Use secret if available, otherwise will be generated in run step
+        MTPROXY_SECRET: ${{ secrets.MTPROXY_SECRET }}
+        # Optional: Only set if secrets are provided (empty means skip telethon test)
+        TELEGRAM_API_ID: ${{ secrets.TELEGRAM_API_ID }}
+        TELEGRAM_API_HASH: ${{ secrets.TELEGRAM_API_HASH }}
+      run: |      
+        if [ -z "$MTPROXY_SECRET" ]; then
+          export MTPROXY_SECRET=$(head -c 16 /dev/urandom | xxd -ps)
+          echo "Generated random MTPROXY_SECRET for testing"
+        fi
+        
+        # Run tests passing env vars
+        make test
+
+  test-direct:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Install Dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y build-essential libssl-dev zlib1g-dev git curl vim-common python3 python3-pip python3-venv netcat-openbsd
+        python3 -m venv .venv
+        source .venv/bin/activate
+        pip install requests telethon python-dotenv python-socks[asyncio]
+
+    - name: Build MTProxy
+      run: |
+        make clean && make -j$(nproc)
+
+    - name: Setup and Run Proxy
+      run: |
+        # Debug: Check connectivity to Telegram DC
+        echo "Checking connectivity to Telegram DC (149.154.175.50:443)..."
+        nc -zv 149.154.175.50 443 || echo "Failed to connect to Telegram DC 149.154.175.50:443"
+        
+        mkdir -p mtproxy-run
+        cp objs/bin/mtproto-proxy mtproxy-run/
+        
+        cd mtproxy-run
+        
+        # Download config/secret 
+        curl -s https://core.telegram.org/getProxySecret -o proxy-secret
+        curl -s https://core.telegram.org/getProxyConfig -o proxy-multi.conf
+        
+        # Generate a random secret for testing using xxd (from vim-common)
+        SECRET=$(head -c 16 /dev/urandom | xxd -ps)
+        echo "Using secret: $SECRET"
+        
+        # Start proxy in background
+        # Use port 8443 instead of 443 to avoid permission issues or conflicts on the runner
+        ./mtproto-proxy -u nobody -p 8888 -H 8443 -S $SECRET --http-stats --aes-pwd proxy-secret proxy-multi.conf -M 1 -v -v &
+        
+        # Export SECRET for the test step
+        echo "MTPROXY_SECRET=$SECRET" >> $GITHUB_ENV
+        
+        # Wait for it to start
+        sleep 5
+
+    - name: Run Python Tests
+      env:
+        # Session path null for CI
+        TEST_SESSION_PATH: /dev/null
+        TELEGRAM_API_ID: ${{ secrets.TELEGRAM_API_ID }}
+        TELEGRAM_API_HASH: ${{ secrets.TELEGRAM_API_HASH }}
+      run: |
+        source .venv/bin/activate
+        # We need to tell the test script to connect to localhost since we are not in docker-compose
+        export MTPROXY_HOST=localhost
+        export MTPROXY_PORT=8443
+        python3 tests/test_proxy.py
+

.gitignore

@@ -1,3 +1,5 @@
 objs
 dep
-.idea/
+.idea
+proxy-multi.conf
+proxy-secret

CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to this project will be documented in this file.
 
+## 2025-11-28
+
+- Fixed high CPU usage (Issue #100):
+  - Optimized `epoll_wait` timeout in `net/net-events.c` to be dynamic based on pending timers.
+  - Corrected `epoll_timeout` handling in `engine/engine.c` and `mtproto/mtproto-proxy.c`.
+- Fixed Docker startup issue (Issue #21):
+  - Added `vim-common` to `Dockerfile` to provide `xxd` for secret generation.
+- Added comprehensive test suite:
+  - Added `tests/` directory with Python-based tests using `telethon`.
+  - Added `make test` target for running tests in Docker.
+  - Added `TESTING.md` documentation.
+  - Added GitHub Actions workflow for automated testing.
+- Build fixes:
+  - Added missing headers (`<x86intrin.h>`) in `engine/engine-rpc.h`.
+  - Suppressed array-bounds warnings for specific files.
+
 ## 2025-09-19
 
 - Added IPv6 usage documentation to `README.md`:

Dockerfile

@@ -1,5 +1,5 @@
-# Use Ubuntu as base image for building
-FROM ubuntu:22.04 AS builder
+# Use Ubuntu as base image for building (force x86_64 for intrinsics support)
+FROM --platform=linux/amd64 ubuntu:22.04 AS builder
 
 # Install build dependencies
 RUN apt-get update && apt-get install -y \
@@ -16,17 +16,18 @@ WORKDIR /src
 COPY . .
 
 # Build the application
-RUN make clean && make
+RUN make clean && make -j$(nproc)
 
-# Runtime image
-FROM ubuntu:22.04
+# Runtime image (must match builder architecture)
+FROM --platform=linux/amd64 ubuntu:22.04
 
 # Install runtime dependencies
 RUN apt-get update && apt-get install -y \
     libssl3 \
     zlib1g \
     curl \
     ca-certificates \
+    vim-common \
     && rm -rf /var/lib/apt/lists/*
 
 # Create user for running the proxy
@@ -75,8 +76,19 @@ WORKERS=\${WORKERS:-1}
 PROXY_TAG=\${PROXY_TAG:-}
 RANDOM_PADDING=\${RANDOM_PADDING:-}
 
+# Detect container-local IPv4 for NAT (used when EXTERNAL_IP is provided).
+LOCAL_IP=\$(grep -vE '(local|ip6|^fd)' /etc/hosts | awk 'NR==1 {print \$1}')
+
+# Optional public IPv4 address to advertise to Telegram DCs; pass via -e EXTERNAL_IP=1.2.3.4
+EXTERNAL_IP=\${EXTERNAL_IP:-}
+
+NAT_INFO_ARGS=""
+if [ -n "\$EXTERNAL_IP" ] && [ -n "\$LOCAL_IP" ]; then
+    NAT_INFO_ARGS="--nat-info \$LOCAL_IP:\$EXTERNAL_IP"
+fi
+
 # Build command
-CMD="./mtproto-proxy -u mtproxy -p \$STATS_PORT -H \$PORT -S \$SECRET --http-stats"
+CMD="./mtproto-proxy -p \$STATS_PORT -H \$PORT -S \$SECRET --http-stats \$NAT_INFO_ARGS"
 
 if [ -n "\$PROXY_TAG" ]; then
     CMD="\$CMD -P \$PROXY_TAG"
@@ -86,7 +98,7 @@ if [ "\$RANDOM_PADDING" = "true" ]; then
     CMD="\$CMD -R"
 fi
 
-CMD="\$CMD --aes-pwd proxy-secret proxy-multi.conf -M \$WORKERS"
+CMD="\$CMD --aes-pwd proxy-secret proxy-multi.conf -M \$WORKERS -u mtproxy \$@"
 
 echo "Starting MTProxy with command: \$CMD"
 exec \$CMD

Makefile

@@ -16,7 +16,7 @@ endif
 HOST_ARCH := $(shell arch)
 
 # Default CFLAGS and LDFLAGS
-COMMON_CFLAGS := -O3 -std=gnu11 -Wall -fno-strict-aliasing -fno-strict-overflow -fwrapv -DAES=1 -DCOMMIT=\"${COMMIT}\" -D_GNU_SOURCE=1 -D_FILE_OFFSET_BITS=64
+COMMON_CFLAGS := -O3 -std=gnu11 -Wall -fno-strict-aliasing -fno-strict-overflow -fwrapv -DAES=1 -DCOMMIT=\"${COMMIT}\" -D_GNU_SOURCE=1 -D_FILE_OFFSET_BITS=64 -Wno-array-bounds -Wno-implicit-function-declaration
 COMMON_LDFLAGS := -ggdb -rdynamic -lm -lrt -lcrypto -lz -lpthread
 
 # Architecture-specific CFLAGS
@@ -129,5 +129,16 @@ docker-run-help-amd64: docker-image-amd64
 	${DOCKER} run --rm --platform ${DOCKER_PLATFORM} --entrypoint /opt/mtproxy/mtproto-proxy ${DOCKER_TEST_IMAGE} 2>&1 | grep -q "Invoking engine"
 
 tests: docker-run-help-amd64
-	@echo "Tests passed: amd64 image builds and binary starts (--help)."
+	@echo "Smoke test passed: amd64 image builds and binary starts (--help)."
+
+test:
+	@# Generate secret if not provided
+	@if [ -z "$$MTPROXY_SECRET" ]; then \
+		export MTPROXY_SECRET=$$(head -c 16 /dev/urandom | xxd -ps); \
+		echo "Generated MTPROXY_SECRET: $$MTPROXY_SECRET"; \
+	fi && \
+	export MTPROXY_SECRET=$${MTPROXY_SECRET:-$$(head -c 16 /dev/urandom | xxd -ps)} && \
+	echo "Using secret: $$MTPROXY_SECRET" && \
+	timeout 1200s docker compose -f tests/docker-compose.test.yml up --build --exit-code-from tester || \
+		(echo "Test timed out or failed"; docker compose -f tests/docker-compose.test.yml down; exit 1)
 

README.md

@@ -57,6 +57,18 @@ make && cd objs/bin
 
 If the build has failed, you should run `make clean` before building it again.
 
+## Testing
+
+This repository includes a comprehensive test suite. For detailed instructions, see [TESTING.md](TESTING.md).
+
+To run the tests using Docker:
+
+```bash
+# Export environment variables (see TESTING.md)
+export MTPROXY_SECRET=...
+make test
+```
+
 ## Running
 1. Obtain a secret, used to connect to telegram servers.
 ```bash
@@ -246,9 +258,37 @@ systemctl enable MTProxy.service
 
 ## Docker
 
-### Using Pre-built Docker Image
+### Quick Start
+
+The simplest way to run MTProxy - no configuration needed:
+
+```bash
+docker run -d \
+  --name mtproxy \
+  -p 443:443 \
+  -p 8888:8888 \
+  --restart unless-stopped \
+  --platform linux/amd64 \
+  ghcr.io/getpagespeed/mtproxy:latest
+```
+
+The container automatically:
+- Downloads the latest proxy configuration from Telegram
+- Generates a random secret if none is provided
+- Starts the proxy on port 443
+
+**Finding Your Auto-Generated Secret:**
 
-The easiest way to run MTProxy is using our pre-built Docker image from GitHub Container Registry:
+```bash
+docker logs mtproxy 2>&1 | grep "Generated secret"
+# Output: Generated secret: abc123def456...
+```
+
+Use this secret to configure your Telegram client.
+
+### Using Pre-built Docker Image (Advanced)
+
+For more control, specify environment variables:
 
 ```bash
 docker run -d \
@@ -272,8 +312,9 @@ docker run -d \
 - `PORT`: Port for client connections (default: 443)
 - `STATS_PORT`: Port for statistics endpoint (default: 8888)
 - `WORKERS`: Number of worker processes (default: 1)
-- `PROXY_TAG`: Proxy tag from [@MTProxybot](https://t.me/MTProxybot)
+- `PROXY_TAG`: Proxy tag from [@MTProxybot](https://t.me/MTProxybot) (optional, for channel promotion)
 - `RANDOM_PADDING`: Enable random padding only mode (true/false, default: false)
+- `EXTERNAL_IP`: Your public IP address for NAT environments (optional)
 
 #### Getting Statistics
 
@@ -283,16 +324,46 @@ curl http://localhost:8888/stats
 
 ### Using Docker Compose
 
-Create a `.env` file:
+The simplest Docker Compose setup (create `docker-compose.yml`):
+
+```yaml
+services:
+  mtproxy:
+    image: ghcr.io/getpagespeed/mtproxy:latest
+    platform: linux/amd64
+    ports:
+      - "443:443"
+      - "8888:8888"
+    restart: unless-stopped
+```
+
+Then run:
+```bash
+docker-compose up -d
+docker-compose logs mtproxy | grep "Generated secret"
+```
+
+For custom configuration, create a `.env` file:
 ```bash
 SECRET=your_secret_here
 PROXY_TAG=your_proxy_tag_here
 RANDOM_PADDING=false
 ```
 
-Then run:
-```bash
-docker-compose up -d
+And reference it in your `docker-compose.yml`:
+```yaml
+services:
+  mtproxy:
+    image: ghcr.io/getpagespeed/mtproxy:latest
+    platform: linux/amd64
+    ports:
+      - "443:443"
+      - "8888:8888"
+    environment:
+      - SECRET=${SECRET}
+      - PROXY_TAG=${PROXY_TAG}
+      - RANDOM_PADDING=${RANDOM_PADDING}
+    restart: unless-stopped
 ```
 
 ### Building Your Own Image
@@ -305,10 +376,15 @@ docker run -d \
   --name mtproxy \
   -p 443:443 \
   -p 8888:8888 \
-  -e SECRET=your_secret_here \
+  --platform linux/amd64 \
   mtproxy
 ```
 
+Check the logs to find your auto-generated secret:
+```bash
+docker logs mtproxy 2>&1 | grep "Generated secret"
+```
+
 ### Health Check
 
 The Docker container includes a health check that monitors the statistics endpoint. You can check the container health with: