OpenVPN

"""novita-openvpn.py

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

import os
import time

from novita_sandbox import Novita

# Path to the local .ovpn client profile (in the project directory).
OVPN_PATH = os.path.join(os.path.dirname(__file__), "..", "client1.ovpn")
REMOTE_CONFIG = "/home/novita/client.ovpn"
REMOTE_LOG = "/tmp/openvpn.log"


def setup_openvpn(ovpn_config: str):
    """Connect a Novita sandbox to an OpenVPN network."""
    novita = Novita(api_key=os.environ["NOVITA_API_KEY"])

    # Create the sandbox
    print("Creating sandbox...")
    sandbox = novita.sandbox.create("base")
    print(f"Sandbox created: {sandbox.sandbox_id}")

    # Step 1: Install 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.")

    # Step 2: Write the OpenVPN config file
    print("\\nWriting OpenVPN configuration...")
    sandbox.files.write(REMOTE_CONFIG, ovpn_config)
    print(f"Configuration written to {REMOTE_CONFIG}")

    # Step 3: Start OpenVPN in background.
    #   `--pull-filter ignore redirect-gateway` stops the server from taking
    #   over the sandbox's default route — otherwise the SDK's own control
    #   connection gets pulled into the tunnel and every later command times
    #   out. The VPN subnet routes are still installed.
    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,
    )

    # Wait for connection to establish
    print("Waiting for VPN connection to establish...")
    time.sleep(10)

    # Step 4: Verify connection — check if the tun0 interface exists
    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()

// Connect a Novita sandbox to an OpenVPN network using a `.ovpn` client
// configuration file (non-interactive).
import fs from 'fs'
import path from 'path'

import { Novita } from 'novita-sandbox'

// Path to the local .ovpn client profile (in the project directory).
const OVPN_PATH = path.join(__dirname, '..', 'client1.ovpn')
const REMOTE_CONFIG = '/home/novita/client.ovpn'
const REMOTE_LOG = '/tmp/openvpn.log'

async function setupOpenVPN(ovpnConfig) {
  const novita = new Novita({ apiKey: process.env.NOVITA_API_KEY })

  // Create the sandbox
  console.log('Creating sandbox...')
  const sandbox = await novita.sandbox.create('base')
  console.log(`Sandbox created: ${sandbox.sandboxId}`)

  // Step 1: Install 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.')

  // Step 2: Write the OpenVPN config file
  console.log('\\nWriting OpenVPN configuration...')
  await sandbox.files.write(REMOTE_CONFIG, ovpnConfig)
  console.log(`Configuration written to ${REMOTE_CONFIG}`)

  // Step 3: Start OpenVPN in background.
  //   `--pull-filter ignore redirect-gateway` stops the server from taking
  //   over the sandbox's default route — otherwise the SDK's own control
  //   connection gets pulled into the tunnel and every later command times
  //   out. The VPN subnet routes are still installed.
  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 }
  )

  // Wait for connection to establish
  console.log('Waiting for VPN connection to establish...')
  await new Promise((r) => setTimeout(r, 10_000))

  // Step 4: Verify connection — check if the tun0 interface exists
  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)