OpenVPN

"""ppio-openvpn.py

Connect a PPIO sandbox to an OpenVPN network using a `.ovpn` client
configuration file (non-interactive).
"""

import os
import time

from ppio_sandbox import PPIO

ppio = PPIO()

# 本地 .ovpn 客户端配置文件路径（位于项目目录中）。
OVPN_PATH = os.path.join(os.path.dirname(__file__), "..", "client1.ovpn")
REMOTE_CONFIG = "/home/user/client.ovpn"
REMOTE_LOG = "/tmp/openvpn.log"

def setup_openvpn(ovpn_config: str):
    """Connect a PPIO sandbox to an OpenVPN network."""

    # 创建 Sandbox
    print("Creating sandbox...")
    sandbox = ppio.sandbox.create("base")
    print(f"Sandbox created: {sandbox.sandbox_id}")

    # 步骤 1：安装 OpenVPN
    print("\\nInstalling OpenVPN...")
    response = sandbox.commands.run(
        "sudo apt update && sudo apt install -y openvpn",
        timeout=300,
    )
    if response.exit_code != 0:
        print(f"Error installing OpenVPN: {response.stderr}")
        return sandbox
    print("OpenVPN installed successfully.")

    # 步骤 2：写入 OpenVPN 配置文件
    print("\\nWriting OpenVPN configuration...")
    sandbox.files.write(REMOTE_CONFIG, ovpn_config)
    print(f"Configuration written to {REMOTE_CONFIG}")

    # 步骤 3：在后台启动 OpenVPN。
    #   `--pull-filter ignore redirect-gateway` 阻止服务端接管
    #   Sandbox 的默认路由 —— 否则 SDK 自身的控制连接
    #   会被卷入隧道，导致后续所有命令超时。
    #   VPN 子网路由仍会被正常安装。
    print("\\nStarting OpenVPN tunnel...")
    sandbox.commands.run(
        f'nohup sudo openvpn --config {REMOTE_CONFIG} '
        f'--pull-filter ignore "redirect-gateway" '
        f"> {REMOTE_LOG} 2>&1 &",
        background=True,
    )

    # 等待连接建立
    print("Waiting for VPN connection to establish...")
    time.sleep(10)

    # 步骤 4：验证连接 —— 检查 tun0 网卡是否存在
    print("\\nVerifying OpenVPN connection...")
    response = sandbox.commands.run("ip addr show tun0 2>/dev/null || true")
    if "inet " in response.stdout:
        print("VPN tunnel interface (tun0) is up:")
        print(response.stdout)
    else:
        print("Warning: tun0 interface not found. Checking OpenVPN logs...")
        log = sandbox.commands.run(f"cat {REMOTE_LOG} 2>/dev/null || true")
        print(f"OpenVPN log:\\n{log.stdout}")
        return sandbox

    print("\\nOpenVPN connection established successfully.")
    return sandbox

def main() -> None:
    with open(OVPN_PATH, "r") as f:
        ovpn_config = f.read().strip()

    sandbox = setup_openvpn(ovpn_config)
    try:
        print("\\nSandbox is connected. Press Ctrl+C to disconnect and kill it.")
        while True:
            time.sleep(3600)
    except KeyboardInterrupt:
        print("\\nInterrupted — shutting down.")
    finally:
        sandbox.kill()
        print("Sandbox killed")

if __name__ == "__main__":
    main()

// 使用 `.ovpn` 客户端配置文件将 PPIO Sandbox 接入 OpenVPN 网络
// （非交互式）。
import fs from 'fs'
import path from 'path'

import { PPIO } from 'ppio-sandbox'

const ppio = new PPIO()

// 本地 .ovpn 客户端配置文件路径（位于项目目录中）。
const OVPN_PATH = path.join(__dirname, '..', 'client1.ovpn')
const REMOTE_CONFIG = '/home/user/client.ovpn'
const REMOTE_LOG = '/tmp/openvpn.log'

async function setupOpenVPN(ovpnConfig) {

  // 创建 Sandbox
  console.log('Creating sandbox...')
  const sandbox = await ppio.sandbox.create('base')
  console.log(`Sandbox created: ${sandbox.sandboxId}`)

  // 步骤 1：安装 OpenVPN
  console.log('\\nInstalling OpenVPN...')
  const install = await sandbox.commands.run(
    'sudo apt update && sudo apt install -y openvpn',
    { timeoutMs: 300_000 }
  )
  if (install.exitCode !== 0) {
    console.log(`Error installing OpenVPN: ${install.stderr}`)
    return sandbox
  }
  console.log('OpenVPN installed successfully.')

  // 步骤 2：写入 OpenVPN 配置文件
  console.log('\\nWriting OpenVPN configuration...')
  await sandbox.files.write(REMOTE_CONFIG, ovpnConfig)
  console.log(`Configuration written to ${REMOTE_CONFIG}`)

  // 步骤 3：在后台启动 OpenVPN。
  //   `--pull-filter ignore redirect-gateway` 阻止服务端接管
  //   Sandbox 的默认路由 —— 否则 SDK 自身的控制连接
  //   会被卷入隧道，导致后续所有命令超时。
  //   VPN 子网路由仍会被正常安装。
  console.log('\\nStarting OpenVPN tunnel...')
  await sandbox.commands.run(
    `nohup sudo openvpn --config ${REMOTE_CONFIG} ` +
      `--pull-filter ignore "redirect-gateway" ` +
      `> ${REMOTE_LOG} 2>&1 &`,
    { background: true }
  )

  // 等待连接建立
  console.log('Waiting for VPN connection to establish...')
  await new Promise((r) => setTimeout(r, 10_000))

  // 步骤 4：验证连接 —— 检查 tun0 网卡是否存在
  console.log('\\nVerifying OpenVPN connection...')
  const res = await sandbox.commands.run('ip addr show tun0 2>/dev/null || true')
  if (res.stdout.includes('inet ')) {
    console.log('VPN tunnel interface (tun0) is up:')
    console.log(res.stdout)
  } else {
    console.log('Warning: tun0 interface not found. Checking OpenVPN logs...')
    const log = await sandbox.commands.run(`cat ${REMOTE_LOG} 2>/dev/null || true`)
    console.log(`OpenVPN log:\\n${log.stdout}`)
    return sandbox
  }

  console.log('\\nOpenVPN connection established successfully.')
  return sandbox
}

async function main() {
  const ovpnConfig = fs.readFileSync(OVPN_PATH, 'utf8').trim()
  const sandbox = await setupOpenVPN(ovpnConfig)
  try {
    console.log('\\nSandbox is connected. Press Ctrl+C to disconnect and kill it.')
    await new Promise(() => {}) // keep running until interrupted
  } finally {
    await sandbox.kill()
    console.log('Sandbox killed')
  }
}

main().catch(console.error)