Auto-refresh video secure tokens

https://cdn.example.com/videos/{id}/{token}/{expires}/master.m3u8

   Player loads          ~10 s before expiry      Fresh token received
   with 60-s URL
        │                       │                         │
   ─────┼───────────────────────┼─────────────────────────┼──────────────▶ time
        │    seamless playback  │   background fetch      │   continues
        │◄───────────────────────────────────────────────►│

┌── Browser ─────────────────────────────────────────────┐
│                                                        │
│  ┌── Video Player ──────────────────────────────────┐  │
│  │                                                  │  │
│  │  ┌────────────────┐  (1) GET /api/token          │  │   ┌──────────────────┐
│  │  │ Token refresh  ├──────────────────────────────────────► Your backend    │
│  │  │ timer / plugin │◄────────────────────────────────────  • verify user    │
│  │  └───────┬────────┘  (2) { token, expires, url } │  │   │ • sign token     │
│  │          │                                       │  │   └──────────────────┘
│  │    (3) update {token}/{expires} in all URLs      │  │
│  │          │                                       │  │
│  │  ┌───────▼────────┐  (4) signed video URL        │  │   ┌──────────────────┐
│  │  │ HLS/DASH       ├─────────────────────────────────────► Gcore CDN        │
│  │  │ URL loader     │◄────────────────────────────────────  • validate token │
│  │  └────────────────┘  (5) video segments          │  │   │ • serve content  │
│  └──────────────────────────────────────────────────┘  │   └──────────────────┘
└────────────────────────────────────────────────────────┘

GET https://video-token-102748.fastedge.app/
    ?video=iKbrdNMcS9ylGuw   # video slug (VOD) or stream ID (Live)
    &type=vod                # vod | live
    &expire=60               # token lifetime in seconds

{
  "token":     "rI1224fiE3USCa8q...",
  "token_ip":  "9y9nJqRofJQw-DbX...",
  "client_ip": "203.0.113.42",
  "expires":   1700000060,
  "url":       "https://demo-protected.gvideo.io/videos/2675_iKbrdNMcS9ylGuw/.../master.m3u8",
  "url_ip":    "https://demo-protected-ip.gvideo.io/videos/2675_iKbrdNMcS9ylGuw/.../master.m3u8"
}

// ┌──────────────────────────────────────────────────────────────────────────┐
// │ FastEdge token API — Gcore Secure Token generator                        │
// │                                                                          │
// │ PURPOSE                                                                  │
// │   Generates signed HLS/DASH URLs for Gcore protected CDN resources.     │
// │   Runs at the edge (no cold starts, <1 ms latency per request).          │
// │                                                                          │
// │ QUERY PARAMETERS                                                         │
// │   video     — video slug (VOD) or stream ID (Live). Required.            │
// │   type      — "vod" | "live". Default: "live".                           │
// │   expire    — token lifetime in seconds, or absolute Unix timestamp.     │
// │               Default: 3600 s.                                           │
// │   client_ip — override client IP for IP-bound token. Default: auto.     │
// │                                                                          │
// │ ENVIRONMENT VARIABLES (set in the FastEdge dashboard)                   │
// │   CLIENT_ID     — your Gcore account ID                                  │
// │   SECRET_KEY    — CDN resource secret key                                │
// │   CDN_DOMAIN    — CDN hostname for plain-token URLs                      │
// │   CDN_DOMAIN_IP — CDN hostname for IP-bound-token URLs                  │
// │                                                                          │
// │ USAGE                                                                    │
// │   This file is an example. Before generating a token, add your own      │
// │   authentication check to verify the user is allowed to access          │
// │   the requested video.                                                   │
// └──────────────────────────────────────────────────────────────────────────┘

use base64::Engine;
use fastedge::body::Body;
use fastedge::http::{Error, Request, Response, StatusCode};
use std::time::{SystemTime, UNIX_EPOCH};

fn get_query_param<'a>(query: &'a str, key: &str) -> Option<&'a str> {
    query.split('&').find_map(|p| {
        let mut kv = p.splitn(2, '=');
        if kv.next() == Some(key) { kv.next() } else { None }
    })
}

/// Generates a Gcore secure token.
/// Formula: base64url( md5( "{client_id}_{video}_{secret}_{expires}_{ip}" ) )
/// Pass ip = "" for plain tokens; pass the viewer's IP for IP-bound tokens.
fn make_token(client_id: &str, video: &str, secret: &str, expires: u64, ip: &str) -> String {
    let hash_input = format!("{}_{}_{}_{}_{}", client_id, video, secret, expires, ip);
    let digest = md5::compute(hash_input.as_bytes());
    let b64 = base64::engine::general_purpose::STANDARD.encode(digest.0);
    b64.replace('+', "-").replace('/', "_").replace('=', "")
}

/// Builds the full HLS master playlist URL with the token embedded in the path:
///   VOD:  https://domain/videos/{client_id}_{video}/{token}/{expires}/master.m3u8
///   Live: https://domain/cmaf/{client_id}_{video}/{token}/{expires}/master.m3u8
fn make_url(domain: &str, client_id: &str, video: &str, token: &str, expires: u64, stream_type: &str) -> String {
    match stream_type {
        "vod" => format!("https://{}/videos/{}_{}/{}/{}/master.m3u8", domain, client_id, video, token, expires),
        _     => format!("https://{}/cmaf/{}_{}/{}/{}/master.m3u8",   domain, client_id, video, token, expires),
    }
}

#[fastedge::http]
fn main(req: Request<Body>) -> Result<Response<Body>, Error> {
    let query = req.uri().query().unwrap_or("");

    // Required: video slug (VOD) or stream ID (Live)
    let video = match get_query_param(query, "video") {
        Some(v) => v,
        None => return Response::builder()
            .status(StatusCode::BAD_REQUEST)
            .header("Content-Type", "application/json")
            .body(Body::from(r#"{"error":"missing required parameter: video"}"#)),
    };

    let stream_type = get_query_param(query, "type").unwrap_or("live");

    // Configuration comes from FastEdge environment variables
    let client_id  = std::env::var("CLIENT_ID").unwrap_or_else(|_| "your-account-id-here".to_string());
    let secret     = std::env::var("SECRET_KEY").unwrap_or_else(|_| "your-secret-token-here".to_string());
    let domain     = std::env::var("CDN_DOMAIN").unwrap_or_else(|_| "demo-protected.gvideo.io".to_string());
    let domain_ip  = std::env::var("CDN_DOMAIN_IP").unwrap_or_else(|_| "demo-protected-ip.gvideo.io".to_string());

    // Detect client IP from request headers (for IP-bound token generation).
    // The caller can override with &client_ip= if the app sits behind a proxy.
    let client_ip = get_query_param(query, "client_ip")
        .map(|s| s.to_string())
        .unwrap_or_else(|| {
            req.headers()
                .get("x-real-ip")
                .or_else(|| req.headers().get("x-forwarded-for"))
                .and_then(|v| v.to_str().ok())
                .map(|s| s.split(',').next().unwrap_or("").trim().to_string())
                .unwrap_or_else(|| "0.0.0.0".to_string())
        });

    // Parse expiry:
    //   missing or <= 0       → now + 3600 s (default)
    //   > 2026-01-01 (Unix)   → treat as an absolute timestamp
    //   otherwise             → now + value seconds
    let now = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0);
    let expires = match get_query_param(query, "expire").and_then(|v| v.parse::<i64>().ok()) {
        Some(v) if v > 1_735_689_600 => v as u64,  // absolute Unix timestamp
        Some(v) if v > 0             => now + v as u64,
        _                            => now + 3600,
    };

    // Generate plain token (empty IP string in the formula)
    let token = make_token(&client_id, video, &secret, expires, "");
    let url   = make_url(&domain, &client_id, video, &token, expires, stream_type);

    // Generate IP-bound token (viewer's IP included in the formula)
    let token_ip = make_token(&client_id, video, &secret, expires, &client_ip);
    let url_ip   = make_url(&domain_ip, &client_id, video, &token_ip, expires, stream_type);

    let json = format!(
        r#"{{"token":"{}","token_ip":"{}","client_ip":"{}","expires":{},"url":"{}","url_ip":"{}"}}"#,
        token, token_ip, client_ip, expires, url, url_ip
    );

    Response::builder()
        .status(StatusCode::OK)
        .header("Content-Type", "application/json")
        .body(Body::from(json))
}

<!DOCTYPE html>
<!--
  AI CONTEXT — Gcore Video Player with TokenRefreshPlugin
  =========================================================
  Protected HLS URL format (token embedded in path, NOT in query params):
    https://cdn.example.com/videos/{id}/{token}/{expires}/master.m3u8

  The token API (TOKEN_API_URL) returns:
    { token, token_ip, client_ip, expires, url, url_ip }
      url    — HLS master URL with plain token (any IP)
      url_ip — HLS master URL with IP-bound token (tied to client_ip)

  TokenRefreshPlugin reads the source URL once at startup to extract the
  initial {token}/{expires} state, then replaces those path segments in
  every subsequent request after each refresh cycle.

  KEY POINTS FOR CODE GENERATION:
  - Fetch initial token BEFORE constructing Player (source URL must be valid)
  - Register TokenRefreshPlugin BEFORE other plugins (CorePlugin ordering)
  - ipBound: false → use url / token; true → use url_ip / token_ip
  - refreshLeadSeconds must be < token lifetime (expire param)
-->
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  <link rel="stylesheet" href="https://player.gvideo.co/v2/assets/latest/index.css" />
</head>
<body>
  <div id="player" style="width:854px; height:480px;"></div>

  <script type="module">
    // Import from the CDN bundle.
    // npm alternative: import { Player, … } from '@gcorevideo/player'
    import {
      Player,
      MediaControl,
      QualityLevels,
      Spinner,
      ErrorScreen,
      TokenRefreshPlugin,
    } from 'https://player.gvideo.co/v2/assets/latest/index.js'

    // ── Token API ───────────────────────────────────────────────────────
    // Replace with your own backend URL. Your server must:
    //   1. Verify the user is authenticated and has access to this video.
    //   2. Return the same JSON shape: { token, token_ip, client_ip, expires, url, url_ip }
    const TOKEN_API_URL =
      'https://video-token-102748.fastedge.app/?video=iKbrdNMcS9ylGuw&type=vod&expire=60'

    async function getToken() {
      const res = await fetch(TOKEN_API_URL)
      if (!res.ok) throw new Error(`Token API returned ${res.status}`)
      return res.json()
    }

    // ── Register plugins ────────────────────────────────────────────────
    // Plugin registration is a class-level (static) operation that applies
    // to every Player instance on the page. Guard against double-registration
    // (e.g. hot-reload in dev or calling init() more than once).
    //
    // Register TokenRefreshPlugin FIRST — it is a CorePlugin that must
    // intercept CORE_CONTAINERS_CREATED before any playback starts.
    if (!Player.corePlugins.some(p => p.prototype?.name === 'token_refresh')) {
      Player.registerPlugin(TokenRefreshPlugin)
    }
    if (!Player.corePlugins.some(p => p.prototype?.name === 'media_control')) {
      Player.registerPlugin(MediaControl)
      Player.registerPlugin(QualityLevels)
      Player.registerPlugin(Spinner)
      Player.registerPlugin(ErrorScreen)
    }

    // ── Fetch initial token ─────────────────────────────────────────────
    // Must be done BEFORE constructing the Player. The Player source URL
    // must already contain a valid {token}/{expires} path — TokenRefreshPlugin
    // reads it once on startup to seed its internal state.
    const tokenData = await getToken()

    // ── Create player ───────────────────────────────────────────────────
    const player = new Player({
      sources: [{
        // Use tokenData.url_ip here (and ipBound: true below) for IP-bound tokens.
        source: tokenData.url,
        mimeType: 'application/x-mpegURL',
      }],
      playbackType: 'vod',    // 'vod' | 'live'

      tokenRefresh: {
        // Called by the plugin ~refreshLeadSeconds before the current token
        // expires. Must return Promise<{ token, token_ip, client_ip, expires, url, url_ip }>.
        getToken,

        // false → use plain token (url / token fields from the response)
        // true  → use IP-bound token (url_ip / token_ip fields)
        ipBound: false,

        // Fetch the replacement token this many seconds before expiry.
        // Must be less than the token lifetime set in TOKEN_API_URL (&expire=60).
        // Recommended: 10 s for 60-s tokens, 30 s for 300-s tokens.
        refreshLeadSeconds: 10,

        // Optional: fired immediately after the plugin applies the new token.
        // Playback is already using the new token at this point — this is
        // purely for logging, analytics, or UI updates.
        onTokenRefreshed(data) {
          console.log('Token refreshed — next expiry:', new Date(data.expires * 1000))
        },
      },
    })

    // Mount the player. Must be the LAST step — attachTo() triggers Clappr's
    // container setup, which fires CORE_CONTAINERS_CREATED and causes
    // TokenRefreshPlugin to inject the URL-rewriting hls.js loader.
    player.attachTo(document.getElementById('player'))
  </script>
</body>
</html>

<!DOCTYPE html>
<!--
  AI CONTEXT — hls.js with custom token-rewriting loader
  ========================================================
  Protected HLS URL format:
    https://cdn.example.com/videos/{id}/{token}/{expires}/master.m3u8

  TOKEN_RE regex targets the {token}/{expires} pair embedded in the path.
  hls.js derives all child URLs (sub-playlists, segments) from the master
  via relative paths, so they all contain the same token/expires segments.
  TokenRewriteLoader intercepts every request and rewrites the URL before
  the XHR is opened.

  KEY POINTS FOR CODE GENERATION:
  - Seed tokenState BEFORE calling hls.loadSource()
  - TokenRewriteLoader must extend Hls.DefaultConfig.loader
  - scheduleRefresh() chains itself — no setInterval needed
  - Use data.token_ip instead of data.token for IP-bound mode
-->
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
</head>
<body>
  <video id="video" controls style="width:854px; height:480px; background:#000;"></video>

  <script src="https://cdn.jsdelivr.net/npm/hls.js@latest/dist/hls.min.js"></script>
  <script>
    // ── Configuration ─────────────────────────────────────────────────────
    // Replace with your own authenticated backend endpoint.
    // Must return: { token, token_ip, client_ip, expires, url, url_ip }
    const TOKEN_API_URL =
      'https://video-token-102748.fastedge.app/?video=iKbrdNMcS9ylGuw&type=vod&expire=60'

    // ── Shared token state ────────────────────────────────────────────────
    // A plain object so the loader closure always reads the current value
    // even after multiple refresh cycles (closures capture the reference,
    // not the value).
    const tokenState = { token: '', expires: 0 }

    // ── Token fetcher ─────────────────────────────────────────────────────
    async function fetchToken() {
      const res = await fetch(TOKEN_API_URL)
      if (!res.ok) throw new Error(`Token API returned ${res.status}`)
      return res.json()
    }

    // ── URL rewriter ──────────────────────────────────────────────────────
    // Matches the {token}/{expires} pair embedded in Gcore CDN URLs.
    // Regex breakdown:
    //   \/                   leading slash
    //   ([A-Za-z0-9_-]{6,})  base64url token (min 6 chars)
    //   \/                   separator
    //   (1\d{9,})            Unix timestamp starting with 1 (covers year 2001–2286)
    //   \/                   trailing slash
    const TOKEN_RE = /\/([A-Za-z0-9_-]{6,})\/(1\d{9,})\//

    function rewriteUrl(url) {
      return url.replace(TOKEN_RE, `/${tokenState.token}/${tokenState.expires}/`)
    }

    // ── Custom hls.js loader ──────────────────────────────────────────────
    // Extends the built-in XHR loader. Intercepts every request (manifest,
    // playlist, segment, key) and rewrites the URL before the connection
    // is opened. This approach works with any hls.js version >= 1.0.
    class TokenRewriteLoader extends Hls.DefaultConfig.loader {
      load(context, config, callbacks) {
        context.url = rewriteUrl(context.url)   // rewrite before XHR opens
        super.load(context, config, callbacks)
      }
    }

    // ── Refresh scheduler ─────────────────────────────────────────────────
    // Uses setTimeout (not setInterval) to chain refreshes. This avoids
    // drift if a fetch takes longer than expected.
    const LEAD_SECONDS = 10   // fetch new token this many seconds before expiry
    let refreshTimer = null

    function scheduleRefresh(expires) {
      clearTimeout(refreshTimer)
      // Fire LEAD_SECONDS before expiry; minimum 1 s to avoid scheduling in the past.
      const msUntilRefresh = Math.max(1000, (expires - Date.now() / 1000 - LEAD_SECONDS) * 1000)
      refreshTimer = setTimeout(doRefresh, msUntilRefresh)
    }

    async function doRefresh() {
      try {
        const data = await fetchToken()
        // Update shared state. The loader picks this up on the next request.
        // Swap data.token → data.token_ip for IP-bound mode.
        tokenState.token   = data.token
        tokenState.expires = data.expires
        console.log('Token refreshed — next expiry:', new Date(data.expires * 1000))
        scheduleRefresh(data.expires)   // schedule the next refresh cycle
      } catch (err) {
        console.error('Token refresh failed:', err)
        setTimeout(doRefresh, 5000)     // retry after 5 s on network error
      }
    }

    // ── Player initialisation ─────────────────────────────────────────────
    async function init() {
      const data = await fetchToken()

      // Seed shared state BEFORE loadSource() so the first request is
      // already rewritten correctly.
      tokenState.token   = data.token    // or data.token_ip for IP-bound
      tokenState.expires = data.expires

      const hls = new Hls({
        loader: TokenRewriteLoader,    // inject the URL-rewriting loader
        // Add other hls.js config options here as needed
      })

      hls.loadSource(data.url)         // protected HLS master playlist
      hls.attachMedia(document.getElementById('video'))

      scheduleRefresh(data.expires)    // start the refresh cycle
    }

    init().catch(err => console.error('Player init failed:', err))
  </script>
</body>
</html>

<!DOCTYPE html>
<!--
  AI CONTEXT — dash.js with RequestModifier for token rewriting
  ==============================================================
  Protected DASH (MPEG-DASH) URL format:
    https://cdn.example.com/cmaf/{id}/{token}/{expires}/index.mpd

  TOKEN_RE and rewriteUrl() are identical to the hls.js example.
  dash.js calls modifyRequest() before every HTTP request (MPD manifest,
  segments, init chunks), so all requests are rewritten transparently.

  KEY POINTS FOR CODE GENERATION:
  - Call player.extend('RequestModifier', ...) BEFORE player.initialize()
  - Convert HLS URL to DASH: replace 'master.m3u8' with 'index.mpd'
  - Seed tokenState BEFORE player.initialize()
  - Use data.token_ip instead of data.token for IP-bound mode
  - player.extend() is compatible with dash.js v3.x and v4.x
-->
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
</head>
<body>
  <video id="video" controls style="width:854px; height:480px; background:#000;"></video>

  <script src="https://cdn.dashjs.org/latest/dash.all.min.js"></script>
  <script>
    // ── Configuration ─────────────────────────────────────────────────────
    // Replace with your own authenticated backend endpoint.
    // Must return: { token, token_ip, client_ip, expires, url, url_ip }
    // Use type=live for Live streams; the token format is identical.
    const TOKEN_API_URL =
      'https://video-token-102748.fastedge.app/?video=iKbrdNMcS9ylGuw&type=live&expire=60'

    // ── Shared token state ────────────────────────────────────────────────
    const tokenState = { token: '', expires: 0 }

    // ── Token fetcher ─────────────────────────────────────────────────────
    async function fetchToken() {
      const res = await fetch(TOKEN_API_URL)
      if (!res.ok) throw new Error(`Token API returned ${res.status}`)
      return res.json()
    }

    // ── URL rewriter ──────────────────────────────────────────────────────
    // Same regex as the hls.js example — Gcore uses the same URL convention
    // for both HLS and DASH (CMAF) streams.
    const TOKEN_RE = /\/([A-Za-z0-9_-]{6,})\/(1\d{9,})\//

    function rewriteUrl(url) {
      return url.replace(TOKEN_RE, `/${tokenState.token}/${tokenState.expires}/`)
    }

    // ── Refresh scheduler ─────────────────────────────────────────────────
    const LEAD_SECONDS = 10
    let refreshTimer = null

    function scheduleRefresh(expires) {
      clearTimeout(refreshTimer)
      const msUntilRefresh = Math.max(1000, (expires - Date.now() / 1000 - LEAD_SECONDS) * 1000)
      refreshTimer = setTimeout(doRefresh, msUntilRefresh)
    }

    async function doRefresh() {
      try {
        const data = await fetchToken()
        tokenState.token   = data.token    // or data.token_ip for IP-bound
        tokenState.expires = data.expires
        console.log('Token refreshed — next expiry:', new Date(data.expires * 1000))
        scheduleRefresh(data.expires)
      } catch (err) {
        console.error('Token refresh failed:', err)
        setTimeout(doRefresh, 5000)
      }
    }

    // ── Player initialisation ─────────────────────────────────────────────
    async function init() {
      const data = await fetchToken()

      // Seed shared state BEFORE initialize() so the first MPD request
      // is already rewritten.
      tokenState.token   = data.token    // or data.token_ip for IP-bound
      tokenState.expires = data.expires

      const player = dashjs.MediaPlayer().create()

      // Register the RequestModifier BEFORE initialize() so it is active
      // for the very first MPD fetch. The modifier is called for every HTTP
      // request dash.js makes — manifest, segments, and init chunks.
      player.extend('RequestModifier', function() {
        return {
          modifyRequest(config) {
            if (config.url) config.url = rewriteUrl(config.url)
            return config
          }
        }
      }, true)

      // The demo token API returns an HLS URL (master.m3u8).
      // For DASH, change the suffix to index.mpd — the token and expires
      // values embedded in the path are the same for both formats.
      const dashUrl = data.url.replace('master.m3u8', 'index.mpd')

      // initialize(videoElement, url, autoPlay)
      player.initialize(document.getElementById('video'), dashUrl, true)

      scheduleRefresh(data.expires)    // start the refresh cycle
    }

    init().catch(err => console.error('Player init failed:', err))
  </script>
</body>
</html>