codesnips
rust 126 lines · 3 tabs

Serving HTTP Range Requests in Axum with Partial Content Responses

Shared by codesnips Aug 2026
3 tabs 
#[derive(Debug, Clone, Copy)]
pub struct ByteRange {
    pub start: u64,
    pub end: u64, // inclusive
}

#[derive(Debug)]
pub enum RangeError {
    Unsatisfiable,
}

impl ByteRange {
    pub fn content_length(&self) -> u64 {
        self.end - self.start + 1
    }

    pub fn parse(header: &str, file_len: u64) -> Option<Result<ByteRange, RangeError>> {
        let spec = header.strip_prefix("bytes=")?;
        if spec.contains(',') {
            return None; // multi-range not supported
        }
        let (raw_start, raw_end) = spec.split_once('-')?;

        let (start, end) = match (raw_start.trim(), raw_end.trim()) {
            ("", suffix) => {
                let n: u64 = suffix.parse().ok()?;
                if n == 0 {
                    return Some(Err(RangeError::Unsatisfiable));
                }
                let n = n.min(file_len);
                (file_len - n, file_len - 1)
            }
            (start, "") => {
                let s: u64 = start.parse().ok()?;
                (s, file_len - 1)
            }
            (start, end) => {
                let s: u64 = start.parse().ok()?;
                let e: u64 = end.parse().ok()?;
                (s, e.min(file_len - 1))
            }
        };

        if file_len == 0 || start >= file_len || start > end {
            return Some(Err(RangeError::Unsatisfiable));
        }
        Some(Ok(ByteRange { start, end }))
    }
}
3 files · rust Explain with highlit

HTTP range requests let clients ask for a byte slice of a resource instead of the whole thing, which is what makes video seeking and resumable downloads work. A server signals support with Accept-Ranges: bytes, and when a request carries a Range header it responds with 206 Partial Content, a Content-Range header, and only the requested bytes. This snippet implements that flow in an Axum handler backed by Tokio file IO.

The range parser tab isolates the fiddly part: turning a header like bytes=200-1023 into a concrete (start, end) pair against a known file length. ByteRange::parse handles the three real shapes the spec allows — start-end, an open-ended start- that runs to the last byte, and a suffix -N meaning the final N bytes. It rejects multi-range requests (the comma case) and syntactically broken input by returning None, which the caller treats as "ignore the header and serve the whole file". Crucially it also validates bounds: if start is past the end of the file the range is unsatisfiable, modeled as a distinct RangeError::Unsatisfiable so the handler can answer with 416.

The file handler tab wires this into Axum. serve_file first stats the file to learn its length, then branches on whether a Range header is present. With no header it returns a normal 200 and the full body. With a valid range it seeks the File to start, wraps a tokio::io::Take so only len bytes are read, and streams that through ReaderStream into a Body — so large files are never buffered in memory. The response sets Content-Range, Content-Length, and the 206 status. An Unsatisfiable range short-circuits to a 416 carrying a Content-Range: bytes */total header, exactly as the spec requires.

The router tab shows the trivial mounting of the route. The design keeps parsing pure and testable while confining IO and header assembly to the handler. A common pitfall it avoids is off-by-one errors: HTTP ranges are inclusive, so the number of bytes to read is end - start + 1, which ByteRange::content_length centralizes. Streaming rather than reading-to-Vec is the other key choice, making the handler safe for gigabyte media files.

Related snips

typescript 
export interface RetryOptions {
  retries: number;
  baseMs: number;
  maxMs: number;
  signal?: AbortSignal;
  onRetry?: (attempt: number, delay: number, err: unknown) => void;

Exponential backoff with jitter for retries

typescript reliability retry
by codesnips 2 tabs
ruby 
require "csv"

class PeopleCsvStream
  include Enumerable

  HEADERS = %w[id full_name email signed_up_at plan].freeze

Resilient CSV Export as a Streamed Response

rails performance streaming
by codesnips 3 tabs
javascript 
// Creating a Promise
const myPromise = new Promise((resolve, reject) => {
  const success = true;

  setTimeout(() => {
    if (success) {

Promises and async/await patterns for asynchronous JavaScript

javascript promises async-await
by Alex Chang 1 tab
typescript 
export type Settled<R> =
  | { status: 'fulfilled'; value: R }
  | { status: 'rejected'; reason: unknown };

export interface ConcurrencyOptions {
  limit: number;

Simple concurrency limiter for batch operations

node concurrency async
by codesnips 2 tabs
go 
package deps

import (
  "net"
  "net/http"
  "time"

HTTP client tuned for production: timeouts, transport, and connection reuse

go http client
by Leah Thompson 1 tab
go 
package api

import (
  "io"
  "net/http"
  "os"

Safe multipart uploads using temp files (bounded memory)

go http uploads
by Leah Thompson 1 tab

Share this code

Here's the card — post it anywhere.

Serving HTTP Range Requests in Axum with Partial Content Responses — share card
Link copied