mirror of
https://github.com/mikkelam/fast-cli.git
synced 2025-12-19 21:34:05 +00:00
Compare commits
No commits in common. "main" and "v0.1.0" have entirely different histories.
15 changed files with 186 additions and 472 deletions
14
.github/workflows/ci.yml
vendored
14
.github/workflows/ci.yml
vendored
|
|
@ -13,8 +13,6 @@ jobs:
|
|||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: mlugg/setup-zig@v2
|
||||
with:
|
||||
version: 0.15.2
|
||||
- run: zig build test
|
||||
- run: zig fmt --check src/
|
||||
|
||||
|
|
@ -30,16 +28,12 @@ jobs:
|
|||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: mlugg/setup-zig@v2
|
||||
with:
|
||||
version: 0.15.2
|
||||
- name: Build ${{ matrix.target }} (${{ matrix.optimize }})
|
||||
run: |
|
||||
zig build --release=${{ matrix.optimize == 'ReleaseSafe' && 'safe' || 'off' }} -Dtarget=${{ matrix.target }}
|
||||
|
||||
- name: Test help command
|
||||
- name: Verify binary
|
||||
if: matrix.target == 'x86_64-linux'
|
||||
run: ./zig-out/bin/fast-cli --help
|
||||
|
||||
- name: Check binary type
|
||||
if: matrix.target == 'x86_64-linux'
|
||||
run: file zig-out/bin/fast-cli
|
||||
run: |
|
||||
./zig-out/bin/fast-cli --help
|
||||
file zig-out/bin/fast-cli
|
||||
|
|
|
|||
6
.github/workflows/release.yml
vendored
6
.github/workflows/release.yml
vendored
|
|
@ -19,11 +19,9 @@ jobs:
|
|||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: mlugg/setup-zig@v2
|
||||
with:
|
||||
version: 0.15.2
|
||||
|
||||
- name: Build
|
||||
run: zig build -Doptimize=ReleaseFast -Dtarget=${{ matrix.target }} -Dcpu=baseline
|
||||
run: zig build --release=safe -Dtarget=${{ matrix.target }}
|
||||
|
||||
- name: Prepare artifact
|
||||
run: |
|
||||
|
|
@ -41,8 +39,6 @@ jobs:
|
|||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: mlugg/setup-zig@v2
|
||||
with:
|
||||
version: 0.15.2
|
||||
- run: zig build test
|
||||
|
||||
release:
|
||||
|
|
|
|||
38
README.md
38
README.md
|
|
@ -1,41 +1,26 @@
|
|||
# fast-cli
|
||||
# fast-cli-zig
|
||||
|
||||
[](https://ziglang.org/)
|
||||
[](https://github.com/mikkelam/fast-cli/actions/workflows/ci.yml)
|
||||
[](https://github.com/mikkelam/fast-cli-zig/actions/workflows/ci.yml)
|
||||
[](https://opensource.org/licenses/MIT)
|
||||
|
||||
A blazingly fast CLI tool for testing internet speed uses fast.com v2 api. Written in Zig for maximum performance.
|
||||
|
||||
⚡ **1.2 MB binary** • 🚀 **Zero runtime deps** • 📊 **Smart stability detection**
|
||||
⚡ **1.3 MiB binary** • 🚀 **Zero runtime deps** • 📊 **Smart stability detection**
|
||||
|
||||
## Demo
|
||||
## Why fast-cli-zig?
|
||||
|
||||
|
||||
|
||||
## Why fast-cli?
|
||||
|
||||
- **Tiny binary**: Just 1.2 MB, no runtime dependencies
|
||||
- **Tiny binary**: Just 1.4 MiB, no runtime dependencies
|
||||
- **Blazing fast**: Concurrent connections with adaptive chunk sizing
|
||||
- **Cross-platform**: Single binary for Linux, macOS
|
||||
- **Cross-platform**: Single binary for Linux, macOS, Windows
|
||||
- **Smart stopping**: Uses Coefficient of Variation (CoV) algorithm for adaptive test duration
|
||||
|
||||
## Supported Platforms
|
||||
|
||||
- **Linux**: x86_64, aarch64 (ARM64)
|
||||
- **macOS**: x86_64 (Intel), aarch64 (aka Apple Silicon)
|
||||
|
||||
## Installation
|
||||
|
||||
### Quick Install
|
||||
|
||||
```bash
|
||||
curl -sSL https://raw.githubusercontent.com/mikkelam/fast-cli/main/install.sh | bash
|
||||
```
|
||||
|
||||
### Pre-built Binaries
|
||||
For example, on an Apple Silicon Mac:
|
||||
```bash
|
||||
curl -L https://github.com/mikkelam/fast-cli/releases/latest/download/fast-cli-aarch64-macos.tar.gz -o fast-cli.tar.gz
|
||||
curl -L https://github.com/mikkelam/fast-cli-zig/releases/latest/download/fast-cli-aarch64-macos.tar.gz -o fast-cli.tar.gz
|
||||
tar -xzf fast-cli.tar.gz
|
||||
chmod +x fast-cli && sudo mv fast-cli /usr/local/bin/
|
||||
fast-cli --help
|
||||
|
|
@ -43,9 +28,9 @@ fast-cli --help
|
|||
|
||||
### Build from Source
|
||||
```bash
|
||||
git clone https://github.com/mikkelam/fast-cli.git
|
||||
cd fast-cli
|
||||
zig build -Doptimize=ReleaseSafe
|
||||
git clone https://github.com/mikkelam/fast-cli-zig.git
|
||||
cd fast-cli-zig
|
||||
zig build --release=safe
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
|
@ -89,8 +74,7 @@ zig build
|
|||
zig build test
|
||||
|
||||
# Release build
|
||||
# Consider removing -Dcpu if you do not need a portable build
|
||||
zig build -Doptimize=ReleaseFast -Dcpu=baseline
|
||||
zig build --release=safe
|
||||
```
|
||||
|
||||
## License
|
||||
|
|
|
|||
49
build.zig
49
build.zig
|
|
@ -4,31 +4,56 @@ pub fn build(b: *std.Build) void {
|
|||
const target = b.standardTargetOptions(.{});
|
||||
const optimize = b.standardOptimizeOption(.{});
|
||||
|
||||
const dep_zli = b.dependency("zli", .{ .target = target });
|
||||
const dep_mvzr = b.dependency("mvzr", .{ .target = target, .optimize = optimize });
|
||||
// library tests
|
||||
const library_tests = b.addTest(.{
|
||||
.root_source_file = b.path("src/test.zig"),
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
});
|
||||
const run_library_tests = b.addRunArtifact(library_tests);
|
||||
|
||||
const test_step = b.step("test", "Run all tests");
|
||||
test_step.dependOn(&run_library_tests.step);
|
||||
|
||||
const dep_zli = b.dependency("zli", .{
|
||||
.target = target,
|
||||
});
|
||||
const mod_zli = dep_zli.module("zli");
|
||||
|
||||
const dep_mvzr = b.dependency("mvzr", .{
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
});
|
||||
const mod_mvzr = dep_mvzr.module("mvzr");
|
||||
|
||||
// Create build options for version info
|
||||
const build_options = b.addOptions();
|
||||
|
||||
// Read version from build.zig.zon at compile time
|
||||
const build_zon_content = @embedFile("build.zig.zon");
|
||||
const version = blk: {
|
||||
// Simple parsing to extract version string
|
||||
const start = std.mem.indexOf(u8, build_zon_content, ".version = \"") orelse unreachable;
|
||||
const version_start = start + ".version = \"".len;
|
||||
const end = std.mem.indexOfPos(u8, build_zon_content, version_start, "\"") orelse unreachable;
|
||||
break :blk build_zon_content[version_start..end];
|
||||
};
|
||||
|
||||
build_options.addOption([]const u8, "version", version);
|
||||
|
||||
const exe = b.addExecutable(.{
|
||||
.name = "fast-cli",
|
||||
.root_module = b.createModule(.{
|
||||
.root_source_file = b.path("src/main.zig"),
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
}),
|
||||
});
|
||||
|
||||
exe.root_module.addImport("zli", dep_zli.module("zli"));
|
||||
exe.root_module.addImport("mvzr", dep_mvzr.module("mvzr"));
|
||||
exe.root_module.addImport("zli", mod_zli);
|
||||
exe.root_module.addImport("mvzr", mod_mvzr);
|
||||
exe.root_module.addImport("build_options", build_options.createModule());
|
||||
library_tests.root_module.addImport("mvzr", mod_mvzr);
|
||||
|
||||
// Link against the static library instead
|
||||
|
||||
b.installArtifact(exe);
|
||||
|
||||
|
|
@ -41,15 +66,5 @@ pub fn build(b: *std.Build) void {
|
|||
const run_step = b.step("run", "Run the app");
|
||||
run_step.dependOn(&run_cmd.step);
|
||||
|
||||
const tests = b.addTest(.{
|
||||
.root_module = b.createModule(.{
|
||||
.root_source_file = b.path("src/test.zig"),
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
}),
|
||||
});
|
||||
tests.root_module.addImport("mvzr", dep_mvzr.module("mvzr"));
|
||||
|
||||
const test_step = b.step("test", "Run tests");
|
||||
test_step.dependOn(&b.addRunArtifact(tests).step);
|
||||
// b.default_step.dependOn(test_step); // Disabled for cross-compilation
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,20 +1,20 @@
|
|||
.{
|
||||
.name = .fast_cli,
|
||||
|
||||
.version = "0.2.4",
|
||||
.version = "0.1.0",
|
||||
|
||||
.fingerprint = 0xfb5a9fbee5075971,
|
||||
.fingerprint = 0xfb5a9fbee5075971, // Changing this has security and trust implications.
|
||||
|
||||
.minimum_zig_version = "0.15.1",
|
||||
.minimum_zig_version = "0.14.0",
|
||||
|
||||
.dependencies = .{
|
||||
.zli = .{
|
||||
.url = "https://github.com/xcaeser/zli/archive/v4.1.1.tar.gz",
|
||||
.hash = "zli-4.1.1-LeUjpljfAAAak_E3L4NPowuzPs_FUF9-jYyxuTSNSthM",
|
||||
},
|
||||
.mvzr = .{
|
||||
.url = "https://github.com/mnemnion/mvzr/archive/refs/tags/v0.3.7.tar.gz",
|
||||
.hash = "mvzr-0.3.7-ZSOky5FtAQB2VrFQPNbXHQCFJxWTMAYEK7ljYEaMR6jt",
|
||||
.url = "https://github.com/mnemnion/mvzr/archive/refs/tags/v0.3.3.tar.gz",
|
||||
.hash = "mvzr-0.3.2-ZSOky95lAQA00lXTN_g8JWoBuh8pw-jyzmCWAqlu1h8L",
|
||||
},
|
||||
.zli = .{
|
||||
.url = "https://github.com/xcaeser/zli/archive/v3.7.0.tar.gz",
|
||||
.hash = "zli-3.7.0-LeUjpq8uAQCl8uh-ws3jdXsnbCwMZQgcZQx4TVXHLSeQ",
|
||||
},
|
||||
},
|
||||
.paths = .{
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
|
Before Width: | Height: | Size: 128 KiB |
209
install.sh
209
install.sh
|
|
@ -1,209 +0,0 @@
|
|||
#!/bin/bash
|
||||
|
||||
set -e
|
||||
|
||||
# Colors for output
|
||||
RED='\033[0;31m'
|
||||
GREEN='\033[0;32m'
|
||||
YELLOW='\033[1;33m'
|
||||
NC='\033[0m' # No Color
|
||||
|
||||
# Default install location
|
||||
DEFAULT_INSTALL_DIR="/usr/local/bin"
|
||||
INSTALL_DIR="${INSTALL_DIR:-$DEFAULT_INSTALL_DIR}"
|
||||
|
||||
# GitHub repository
|
||||
REPO="mikkelam/fast-cli"
|
||||
BINARY_NAME="fast-cli"
|
||||
|
||||
# Print colored output
|
||||
print_status() {
|
||||
echo -e "${GREEN}[INFO]${NC} $1"
|
||||
}
|
||||
|
||||
print_warning() {
|
||||
echo -e "${YELLOW}[WARN]${NC} $1"
|
||||
}
|
||||
|
||||
print_error() {
|
||||
echo -e "${RED}[ERROR]${NC} $1"
|
||||
}
|
||||
|
||||
# Detect OS and architecture
|
||||
detect_platform() {
|
||||
local os arch
|
||||
|
||||
case "$(uname -s)" in
|
||||
Linux*)
|
||||
os="linux"
|
||||
;;
|
||||
Darwin*)
|
||||
os="macos"
|
||||
;;
|
||||
*)
|
||||
print_error "Unsupported operating system: $(uname -s)"
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
|
||||
case "$(uname -m)" in
|
||||
x86_64|amd64)
|
||||
arch="x86_64"
|
||||
;;
|
||||
aarch64|arm64)
|
||||
arch="aarch64"
|
||||
;;
|
||||
armv7l)
|
||||
arch="armv7"
|
||||
;;
|
||||
*)
|
||||
print_error "Unsupported architecture: $(uname -m)"
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
|
||||
echo "${BINARY_NAME}-${arch}-${os}"
|
||||
}
|
||||
|
||||
# Get latest release version
|
||||
get_latest_version() {
|
||||
local version
|
||||
version=$(curl -s "https://api.github.com/repos/${REPO}/releases/latest" | grep '"tag_name":' | sed -E 's/.*"([^"]+)".*/\1/')
|
||||
|
||||
if [ -z "$version" ]; then
|
||||
print_error "Failed to get latest version"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "$version"
|
||||
}
|
||||
|
||||
# Download and install
|
||||
install_fast_cli() {
|
||||
local platform version download_url temp_dir
|
||||
|
||||
print_status "Detecting platform..."
|
||||
platform=$(detect_platform)
|
||||
print_status "Platform detected: $platform"
|
||||
|
||||
print_status "Getting latest version..."
|
||||
version=$(get_latest_version)
|
||||
print_status "Latest version: $version"
|
||||
|
||||
# Create download URL
|
||||
download_url="https://github.com/${REPO}/releases/latest/download/${platform}.tar.gz"
|
||||
|
||||
# Create temporary directory
|
||||
temp_dir=$(mktemp -d)
|
||||
trap "rm -rf $temp_dir" EXIT
|
||||
|
||||
print_status "Downloading fast-cli..."
|
||||
if ! curl -L --fail --silent --show-error "$download_url" -o "$temp_dir/fast-cli.tar.gz"; then
|
||||
print_error "Failed to download fast-cli from $download_url"
|
||||
print_error "Please check if a release exists for your platform"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
print_status "Extracting archive..."
|
||||
if ! tar -xzf "$temp_dir/fast-cli.tar.gz" -C "$temp_dir"; then
|
||||
print_error "Failed to extract archive"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Check if we need sudo for installation
|
||||
if [ ! -w "$INSTALL_DIR" ]; then
|
||||
if [ "$INSTALL_DIR" = "$DEFAULT_INSTALL_DIR" ]; then
|
||||
print_warning "Installing to $INSTALL_DIR requires sudo privileges"
|
||||
SUDO="sudo"
|
||||
else
|
||||
print_error "No write permission to $INSTALL_DIR"
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
print_status "Installing to $INSTALL_DIR..."
|
||||
$SUDO mkdir -p "$INSTALL_DIR"
|
||||
$SUDO cp "$temp_dir/$BINARY_NAME" "$INSTALL_DIR/$BINARY_NAME"
|
||||
$SUDO chmod +x "$INSTALL_DIR/$BINARY_NAME"
|
||||
|
||||
print_status "Installation complete!"
|
||||
echo
|
||||
echo -e "${GREEN}✓${NC} fast-cli installed to $INSTALL_DIR/$BINARY_NAME"
|
||||
echo
|
||||
echo "Try it out:"
|
||||
echo " $BINARY_NAME --help"
|
||||
echo " $BINARY_NAME --json"
|
||||
}
|
||||
|
||||
# Show usage
|
||||
show_usage() {
|
||||
cat << EOF
|
||||
Fast-CLI Installer
|
||||
|
||||
Usage: $0 [OPTIONS]
|
||||
|
||||
Options:
|
||||
--prefix DIR Install to custom directory (default: $DEFAULT_INSTALL_DIR)
|
||||
--help Show this help message
|
||||
|
||||
Environment Variables:
|
||||
INSTALL_DIR Custom installation directory
|
||||
|
||||
Examples:
|
||||
# Install to default location
|
||||
$0
|
||||
|
||||
# Install to custom directory
|
||||
$0 --prefix /opt/bin
|
||||
INSTALL_DIR=/opt/bin $0
|
||||
|
||||
EOF
|
||||
}
|
||||
|
||||
# Parse command line arguments
|
||||
while [[ $# -gt 0 ]]; do
|
||||
case $1 in
|
||||
--prefix)
|
||||
INSTALL_DIR="$2"
|
||||
shift 2
|
||||
;;
|
||||
--help|-h)
|
||||
show_usage
|
||||
exit 0
|
||||
;;
|
||||
*)
|
||||
print_error "Unknown option: $1"
|
||||
show_usage
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
# Check dependencies
|
||||
check_dependencies() {
|
||||
local missing_deps=()
|
||||
|
||||
for cmd in curl tar; do
|
||||
if ! command -v "$cmd" > /dev/null 2>&1; then
|
||||
missing_deps+=("$cmd")
|
||||
fi
|
||||
done
|
||||
|
||||
if [ ${#missing_deps[@]} -ne 0 ]; then
|
||||
print_error "Missing required dependencies: ${missing_deps[*]}"
|
||||
print_error "Please install them and try again"
|
||||
exit 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Main
|
||||
main() {
|
||||
echo "Fast-CLI Installer"
|
||||
echo "=================="
|
||||
echo
|
||||
|
||||
check_dependencies
|
||||
install_fast_cli
|
||||
}
|
||||
|
||||
main "$@"
|
||||
104
src/cli/root.zig
104
src/cli/root.zig
|
|
@ -1,9 +1,6 @@
|
|||
const std = @import("std");
|
||||
const zli = @import("zli");
|
||||
const builtin = @import("builtin");
|
||||
const Writer = std.Io.Writer;
|
||||
|
||||
const log = std.log.scoped(.cli);
|
||||
|
||||
const Fast = @import("../lib/fast.zig").Fast;
|
||||
const HTTPSpeedTester = @import("../lib/http_speed_tester_v2.zig").HTTPSpeedTester;
|
||||
|
|
@ -14,6 +11,17 @@ const BandwidthMeter = @import("../lib/bandwidth.zig");
|
|||
const SpeedMeasurement = @import("../lib/bandwidth.zig").SpeedMeasurement;
|
||||
const progress = @import("../lib/progress.zig");
|
||||
const HttpLatencyTester = @import("../lib/http_latency_tester.zig").HttpLatencyTester;
|
||||
const log = std.log.scoped(.cli);
|
||||
|
||||
/// Update spinner text with current speed measurement
|
||||
fn updateSpinnerText(spinner: anytype, measurement: SpeedMeasurement) void {
|
||||
spinner.updateText("⬇️ {d:.1} {s}", .{ measurement.value, measurement.unit.toString() }) catch {};
|
||||
}
|
||||
|
||||
/// Update spinner text with current upload speed measurement
|
||||
fn updateUploadSpinnerText(spinner: anytype, measurement: SpeedMeasurement) void {
|
||||
spinner.updateText("⬆️ {d:.1} {s}", .{ measurement.value, measurement.unit.toString() }) catch {};
|
||||
}
|
||||
|
||||
const https_flag = zli.Flag{
|
||||
.name = "https",
|
||||
|
|
@ -46,8 +54,8 @@ const max_duration_flag = zli.Flag{
|
|||
.default_value = .{ .Int = 30 },
|
||||
};
|
||||
|
||||
pub fn build(writer: *Writer, allocator: std.mem.Allocator) !*zli.Command {
|
||||
const root = try zli.Command.init(writer, allocator, .{
|
||||
pub fn build(allocator: std.mem.Allocator) !*zli.Command {
|
||||
const root = try zli.Command.init(allocator, .{
|
||||
.name = "fast-cli",
|
||||
.description = "Estimate connection speed using fast.com",
|
||||
.version = null,
|
||||
|
|
@ -67,41 +75,35 @@ fn run(ctx: zli.CommandContext) !void {
|
|||
const json_output = ctx.flag("json", bool);
|
||||
const max_duration = ctx.flag("duration", i64);
|
||||
|
||||
const spinner = ctx.spinner;
|
||||
|
||||
log.info("Config: https={}, upload={}, json={}, max_duration={}s", .{
|
||||
use_https, check_upload, json_output, max_duration,
|
||||
});
|
||||
|
||||
var fast = Fast.init(std.heap.smp_allocator, use_https);
|
||||
var fast = Fast.init(std.heap.page_allocator, use_https);
|
||||
defer fast.deinit();
|
||||
|
||||
const urls = fast.get_urls(5) catch |err| {
|
||||
if (!json_output) {
|
||||
try spinner.fail("Failed to get URLs: {}", .{err});
|
||||
try ctx.spinner.fail("Failed to get URLs: {}", .{err});
|
||||
} else {
|
||||
const error_msg = switch (err) {
|
||||
error.ConnectionTimeout => "Failed to contact fast.com servers",
|
||||
else => "Failed to get URLs",
|
||||
};
|
||||
try outputJson(ctx.writer, null, null, null, error_msg);
|
||||
std.debug.print("{{\"error\": \"{}\"}}\n", .{err});
|
||||
}
|
||||
return;
|
||||
};
|
||||
|
||||
log.info("Got {} URLs\n", .{urls.len});
|
||||
log.info("Got {} URLs", .{urls.len});
|
||||
for (urls) |url| {
|
||||
log.info("URL: {s}\n", .{url});
|
||||
log.debug("URL: {s}", .{url});
|
||||
}
|
||||
|
||||
// Measure latency first
|
||||
var latency_tester = HttpLatencyTester.init(std.heap.smp_allocator);
|
||||
var latency_tester = HttpLatencyTester.init(std.heap.page_allocator);
|
||||
defer latency_tester.deinit();
|
||||
|
||||
const latency_ms = if (!json_output) blk: {
|
||||
try spinner.start("Measuring latency...", .{});
|
||||
try ctx.spinner.start(.{}, "Measuring latency...", .{});
|
||||
const result = latency_tester.measureLatency(urls) catch |err| {
|
||||
try spinner.fail("Latency test failed: {}", .{err});
|
||||
log.err("Latency test failed: {}", .{err});
|
||||
break :blk null;
|
||||
};
|
||||
break :blk result;
|
||||
|
|
@ -110,11 +112,11 @@ fn run(ctx: zli.CommandContext) !void {
|
|||
};
|
||||
|
||||
if (!json_output) {
|
||||
log.info("Measuring download speed...", .{});
|
||||
try ctx.spinner.start(.{}, "Measuring download speed...", .{});
|
||||
}
|
||||
|
||||
// Initialize speed tester
|
||||
var speed_tester = HTTPSpeedTester.init(std.heap.smp_allocator);
|
||||
var speed_tester = HTTPSpeedTester.init(std.heap.page_allocator);
|
||||
defer speed_tester.deinit();
|
||||
|
||||
// Use Fast.com-style stability detection by default
|
||||
|
|
@ -130,15 +132,15 @@ fn run(ctx: zli.CommandContext) !void {
|
|||
const download_result = if (json_output) blk: {
|
||||
// JSON mode: clean output only
|
||||
break :blk speed_tester.measure_download_speed_stability(urls, criteria) catch |err| {
|
||||
try spinner.fail("Download test failed: {}", .{err});
|
||||
try outputJson(ctx.writer, null, null, null, "Download test failed");
|
||||
log.err("Download test failed: {}", .{err});
|
||||
std.debug.print("{{\"error\": \"{}\"}}\n", .{err});
|
||||
return;
|
||||
};
|
||||
} else blk: {
|
||||
// Interactive mode with spinner updates
|
||||
const progressCallback = progress.createCallback(spinner, updateSpinnerText);
|
||||
const progressCallback = progress.createCallback(ctx.spinner, updateSpinnerText);
|
||||
break :blk speed_tester.measureDownloadSpeedWithStabilityProgress(urls, criteria, progressCallback) catch |err| {
|
||||
try spinner.fail("Download test failed: {}", .{err});
|
||||
try ctx.spinner.fail("Download test failed: {}", .{err});
|
||||
return;
|
||||
};
|
||||
};
|
||||
|
|
@ -146,21 +148,21 @@ fn run(ctx: zli.CommandContext) !void {
|
|||
var upload_result: ?SpeedTestResult = null;
|
||||
if (check_upload) {
|
||||
if (!json_output) {
|
||||
log.info("Measuring upload speed...", .{});
|
||||
try ctx.spinner.start(.{}, "Measuring upload speed...", .{});
|
||||
}
|
||||
|
||||
upload_result = if (json_output) blk: {
|
||||
// JSON mode: clean output only
|
||||
break :blk speed_tester.measure_upload_speed_stability(urls, criteria) catch |err| {
|
||||
try spinner.fail("Upload test failed: {}", .{err});
|
||||
try outputJson(ctx.writer, download_result.speed.value, latency_ms, null, "Upload test failed");
|
||||
log.err("Upload test failed: {}", .{err});
|
||||
std.debug.print("{{\"error\": \"{}\"}}\n", .{err});
|
||||
return;
|
||||
};
|
||||
} else blk: {
|
||||
// Interactive mode with spinner updates
|
||||
const uploadProgressCallback = progress.createCallback(spinner, updateUploadSpinnerText);
|
||||
const uploadProgressCallback = progress.createCallback(ctx.spinner, updateUploadSpinnerText);
|
||||
break :blk speed_tester.measureUploadSpeedWithStabilityProgress(urls, criteria, uploadProgressCallback) catch |err| {
|
||||
try spinner.fail("Upload test failed: {}", .{err});
|
||||
try ctx.spinner.fail("Upload test failed: {}", .{err});
|
||||
return;
|
||||
};
|
||||
};
|
||||
|
|
@ -170,43 +172,25 @@ fn run(ctx: zli.CommandContext) !void {
|
|||
if (!json_output) {
|
||||
if (latency_ms) |ping| {
|
||||
if (upload_result) |up| {
|
||||
try spinner.succeed("🏓 {d:.0}ms | ⬇️ Download: {d:.1} {s} | ⬆️ Upload: {d:.1} {s}", .{ ping, download_result.speed.value, download_result.speed.unit.toString(), up.speed.value, up.speed.unit.toString() });
|
||||
try ctx.spinner.succeed("🏓 {d:.0}ms | ⬇️ Download: {d:.1} {s} | ⬆️ Upload: {d:.1} {s}", .{ ping, download_result.speed.value, download_result.speed.unit.toString(), up.speed.value, up.speed.unit.toString() });
|
||||
} else {
|
||||
try spinner.succeed("🏓 {d:.0}ms | ⬇️ Download: {d:.1} {s}", .{ ping, download_result.speed.value, download_result.speed.unit.toString() });
|
||||
try ctx.spinner.succeed("🏓 {d:.0}ms | ⬇️ Download: {d:.1} {s}", .{ ping, download_result.speed.value, download_result.speed.unit.toString() });
|
||||
}
|
||||
} else {
|
||||
if (upload_result) |up| {
|
||||
try spinner.succeed("⬇️ Download: {d:.1} {s} | ⬆️ Upload: {d:.1} {s}", .{ download_result.speed.value, download_result.speed.unit.toString(), up.speed.value, up.speed.unit.toString() });
|
||||
try ctx.spinner.succeed("⬇️ Download: {d:.1} {s} | ⬆️ Upload: {d:.1} {s}", .{ download_result.speed.value, download_result.speed.unit.toString(), up.speed.value, up.speed.unit.toString() });
|
||||
} else {
|
||||
try spinner.succeed("⬇️ Download: {d:.1} {s}", .{ download_result.speed.value, download_result.speed.unit.toString() });
|
||||
try ctx.spinner.succeed("⬇️ Download: {d:.1} {s}", .{ download_result.speed.value, download_result.speed.unit.toString() });
|
||||
}
|
||||
}
|
||||
} else {
|
||||
const upload_speed = if (upload_result) |up| up.speed.value else null;
|
||||
try outputJson(ctx.writer, download_result.speed.value, latency_ms, upload_speed, null);
|
||||
std.debug.print("{{\"download_mbps\": {d:.1}", .{download_result.speed.value});
|
||||
if (latency_ms) |ping| {
|
||||
std.debug.print(", \"ping_ms\": {d:.1}", .{ping});
|
||||
}
|
||||
if (upload_result) |up| {
|
||||
std.debug.print(", \"upload_mbps\": {d:.1}", .{up.speed.value});
|
||||
}
|
||||
std.debug.print("}}\n", .{});
|
||||
}
|
||||
}
|
||||
|
||||
/// Update spinner text with current speed measurement
|
||||
fn updateSpinnerText(spinner: anytype, measurement: SpeedMeasurement) void {
|
||||
spinner.updateMessage("⬇️ {d:.1} {s}", .{ measurement.value, measurement.unit.toString() }) catch {};
|
||||
}
|
||||
|
||||
/// Update spinner text with current upload speed measurement
|
||||
fn updateUploadSpinnerText(spinner: anytype, measurement: SpeedMeasurement) void {
|
||||
spinner.updateMessage("⬆️ {d:.1} {s}", .{ measurement.value, measurement.unit.toString() }) catch {};
|
||||
}
|
||||
|
||||
fn outputJson(writer: *Writer, download_mbps: ?f64, ping_ms: ?f64, upload_mbps: ?f64, error_message: ?[]const u8) !void {
|
||||
var download_buf: [32]u8 = undefined;
|
||||
var ping_buf: [32]u8 = undefined;
|
||||
var upload_buf: [32]u8 = undefined;
|
||||
var error_buf: [256]u8 = undefined;
|
||||
|
||||
const download_str = if (download_mbps) |d| try std.fmt.bufPrint(&download_buf, "{d:.1}", .{d}) else "null";
|
||||
const ping_str = if (ping_ms) |p| try std.fmt.bufPrint(&ping_buf, "{d:.1}", .{p}) else "null";
|
||||
const upload_str = if (upload_mbps) |u| try std.fmt.bufPrint(&upload_buf, "{d:.1}", .{u}) else "null";
|
||||
const error_str = if (error_message) |e| try std.fmt.bufPrint(&error_buf, "\"{s}\"", .{e}) else "null";
|
||||
|
||||
try writer.print("{{\"download_mbps\": {s}, \"ping_ms\": {s}, \"upload_mbps\": {s}, \"error\": {s}}}\n", .{ download_str, ping_str, upload_str, error_str });
|
||||
}
|
||||
|
|
|
|||
|
|
@ -107,7 +107,7 @@ test "BandwidthMeter bandwidth calculation" {
|
|||
meter.update_total(1000); // 1000 bytes
|
||||
|
||||
// Sleep briefly to ensure time passes
|
||||
std.Thread.sleep(std.time.ns_per_ms * 10); // 10ms
|
||||
std.time.sleep(std.time.ns_per_ms * 10); // 10ms
|
||||
|
||||
const bw = meter.bandwidth();
|
||||
try testing.expect(bw > 0);
|
||||
|
|
@ -127,7 +127,7 @@ test "BandwidthMeter unit conversion" {
|
|||
// Test different speed ranges
|
||||
meter._bytes_transferred = 1000;
|
||||
meter._timer = try std.time.Timer.start();
|
||||
std.Thread.sleep(std.time.ns_per_s); // 1 second
|
||||
std.time.sleep(std.time.ns_per_s); // 1 second
|
||||
|
||||
const measurement = meter.bandwidthWithUnits();
|
||||
|
||||
|
|
|
|||
|
|
@ -6,28 +6,29 @@ const testing = std.testing;
|
|||
const log = std.log.scoped(.fast_api);
|
||||
|
||||
const mvzr = @import("mvzr");
|
||||
|
||||
const FastError = error{
|
||||
HttpRequestFailed,
|
||||
ScriptNotFound,
|
||||
TokenNotFound,
|
||||
JsonParseError,
|
||||
ConnectionTimeout,
|
||||
};
|
||||
|
||||
const Location = struct { city: []const u8, country: []const u8 };
|
||||
const Location = struct {
|
||||
city: []const u8,
|
||||
country: []const u8,
|
||||
};
|
||||
|
||||
const Client = struct {
|
||||
ip: []const u8,
|
||||
asn: ?[]const u8 = null,
|
||||
isp: ?[]const u8 = null,
|
||||
location: ?Location = null,
|
||||
asn: []const u8,
|
||||
isp: []const u8,
|
||||
location: Location,
|
||||
};
|
||||
|
||||
const Target = struct {
|
||||
name: []const u8,
|
||||
url: []const u8,
|
||||
location: ?Location = null,
|
||||
location: Location,
|
||||
};
|
||||
|
||||
const FastResponse = struct {
|
||||
|
|
@ -71,7 +72,7 @@ pub const Fast = struct {
|
|||
|
||||
var result = try Fast.parse_response_urls(json_data.items, allocator);
|
||||
|
||||
return result.toOwnedSlice(allocator);
|
||||
return result.toOwnedSlice();
|
||||
}
|
||||
|
||||
/// Sanitizes JSON data by replacing invalid UTF-8 bytes that cause parseFromSlice to fail.
|
||||
|
|
@ -102,7 +103,7 @@ pub const Fast = struct {
|
|||
}
|
||||
|
||||
fn parse_response_urls(json_data: []const u8, result_allocator: std.mem.Allocator) !std.ArrayList([]const u8) {
|
||||
var result = std.ArrayList([]const u8).empty;
|
||||
var result = std.ArrayList([]const u8).init(result_allocator);
|
||||
|
||||
const sanitized_json = try sanitize_json(json_data, result_allocator);
|
||||
defer result_allocator.free(sanitized_json);
|
||||
|
|
@ -119,7 +120,7 @@ pub const Fast = struct {
|
|||
|
||||
for (response.targets) |target| {
|
||||
const url_copy = try result_allocator.dupe(u8, target.url);
|
||||
try result.append(result_allocator, url_copy);
|
||||
try result.append(url_copy);
|
||||
}
|
||||
|
||||
return result;
|
||||
|
|
@ -155,39 +156,14 @@ pub const Fast = struct {
|
|||
}
|
||||
|
||||
fn get_page(self: *Fast, allocator: std.mem.Allocator, url: []const u8) !std.ArrayList(u8) {
|
||||
var response_body = std.Io.Writer.Allocating.init(allocator);
|
||||
_ = allocator;
|
||||
var response_body = std.ArrayList(u8).init(self.arena.allocator());
|
||||
|
||||
const response: http.Client.FetchResult = self.client.fetch(.{
|
||||
const response: http.Client.FetchResult = try self.client.fetch(.{
|
||||
.method = .GET,
|
||||
.location = .{ .url = url },
|
||||
.response_writer = &response_body.writer,
|
||||
// .response_storage = .{ .dynamic = &response_body },
|
||||
}) catch |err| switch (err) {
|
||||
error.NetworkUnreachable, error.ConnectionRefused => {
|
||||
log.err("Failed to reach fast.com servers (network/connection error) for URL: {s}", .{url});
|
||||
return error.ConnectionTimeout;
|
||||
},
|
||||
error.UnknownHostName, error.NameServerFailure, error.TemporaryNameServerFailure, error.HostLacksNetworkAddresses => {
|
||||
log.err("Failed to resolve fast.com hostname (DNS/internet connection issue) for URL: {s}", .{url});
|
||||
return error.ConnectionTimeout;
|
||||
},
|
||||
error.ConnectionTimedOut, error.ConnectionResetByPeer => {
|
||||
log.err("Connection to fast.com servers timed out or was reset for URL: {s}", .{url});
|
||||
return error.ConnectionTimeout;
|
||||
},
|
||||
error.TlsInitializationFailed => {
|
||||
log.err("Failed to establish secure connection to fast.com servers for URL: {s}", .{url});
|
||||
return error.ConnectionTimeout;
|
||||
},
|
||||
error.UnexpectedConnectFailure => {
|
||||
log.err("Unexpected connection failure to fast.com servers for URL: {s}", .{url});
|
||||
return error.ConnectionTimeout;
|
||||
},
|
||||
else => {
|
||||
log.err("Network error: {} for URL: {s}", .{ err, url });
|
||||
return error.ConnectionTimeout;
|
||||
},
|
||||
};
|
||||
.response_storage = .{ .dynamic = &response_body },
|
||||
});
|
||||
|
||||
log.debug("HTTP response status: {} for URL: {s}", .{ response.status, url });
|
||||
|
||||
|
|
@ -195,7 +171,7 @@ pub const Fast = struct {
|
|||
log.err("HTTP request failed with status code {}", .{response.status});
|
||||
return error.HttpRequestFailed;
|
||||
}
|
||||
return response_body.toArrayList();
|
||||
return response_body;
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -205,12 +181,12 @@ test "parse_response_urls_v2" {
|
|||
;
|
||||
const allocator = testing.allocator;
|
||||
|
||||
var urls = try Fast.parse_response_urls(response, allocator);
|
||||
const urls = try Fast.parse_response_urls(response, allocator);
|
||||
defer {
|
||||
for (urls.items) |url| {
|
||||
allocator.free(url);
|
||||
}
|
||||
urls.deinit(allocator);
|
||||
urls.deinit();
|
||||
}
|
||||
|
||||
try testing.expect(urls.items.len == 2);
|
||||
|
|
@ -268,39 +244,3 @@ test "extract_token" {
|
|||
defer allocator.free(token);
|
||||
try testing.expect(std.mem.eql(u8, token, "abcdef123456"));
|
||||
}
|
||||
|
||||
test "parse_response_without_isp" {
|
||||
const response =
|
||||
\\{"client":{"ip":"87.52.107.67","asn":"3292","location":{"city":"Test","country":"DK"}},"targets":[{"name":"https://example.com/0","url":"https://example.com/0","location":{"city":"Test","country":"DK"}}]}
|
||||
;
|
||||
const allocator = testing.allocator;
|
||||
|
||||
var urls = try Fast.parse_response_urls(response, allocator);
|
||||
defer {
|
||||
for (urls.items) |url| {
|
||||
allocator.free(url);
|
||||
}
|
||||
urls.deinit(allocator);
|
||||
}
|
||||
|
||||
try testing.expect(urls.items.len == 1);
|
||||
try testing.expect(std.mem.eql(u8, urls.items[0], "https://example.com/0"));
|
||||
}
|
||||
|
||||
test "parse_response_minimal_client" {
|
||||
const response =
|
||||
\\{"client":{"ip":"87.52.107.67"},"targets":[{"name":"https://example.com/0","url":"https://example.com/0"}]}
|
||||
;
|
||||
const allocator = testing.allocator;
|
||||
|
||||
var urls = try Fast.parse_response_urls(response, allocator);
|
||||
defer {
|
||||
for (urls.items) |url| {
|
||||
allocator.free(url);
|
||||
}
|
||||
urls.deinit(allocator);
|
||||
}
|
||||
|
||||
try testing.expect(urls.items.len == 1);
|
||||
try testing.expect(std.mem.eql(u8, urls.items[0], "https://example.com/0"));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,5 @@
|
|||
const std = @import("std");
|
||||
const http = std.http;
|
||||
const log = std.log.scoped(.cli);
|
||||
|
||||
pub const HttpLatencyTester = struct {
|
||||
allocator: std.mem.Allocator,
|
||||
|
|
@ -19,22 +18,16 @@ pub const HttpLatencyTester = struct {
|
|||
|
||||
/// Measure latency to multiple URLs using HEAD requests
|
||||
/// Returns median latency in milliseconds, or null if all requests failed
|
||||
/// Zig's http client seems to be ~20ms slower than curl.
|
||||
/// Let's not worry about that misreporting for now
|
||||
pub fn measureLatency(self: *Self, urls: []const []const u8) !?f64 {
|
||||
if (urls.len == 0) return null;
|
||||
|
||||
var latencies: std.ArrayList(f64) = .{};
|
||||
defer latencies.deinit(self.allocator);
|
||||
|
||||
// HTTP client for all requests
|
||||
var client = http.Client{ .allocator = self.allocator };
|
||||
defer client.deinit();
|
||||
var latencies = std.ArrayList(f64).init(self.allocator);
|
||||
defer latencies.deinit();
|
||||
|
||||
// Test each URL
|
||||
for (urls) |url| {
|
||||
if (self.measureSingleUrl(url, &client)) |latency_ms| {
|
||||
try latencies.append(self.allocator, latency_ms);
|
||||
if (self.measureSingleUrl(url)) |latency_ms| {
|
||||
try latencies.append(latency_ms);
|
||||
} else |_| {
|
||||
// Ignore errors, continue with other URLs
|
||||
continue;
|
||||
|
|
@ -43,26 +36,50 @@ pub const HttpLatencyTester = struct {
|
|||
|
||||
if (latencies.items.len == 0) return null;
|
||||
|
||||
log.info("Latencies: {any}", .{latencies.items});
|
||||
|
||||
// Return median latency
|
||||
return self.calculateMedian(latencies.items);
|
||||
}
|
||||
|
||||
/// Measure latency to a single URL using HEAD request
|
||||
fn measureSingleUrl(self: *Self, url: []const u8, client: *http.Client) !f64 {
|
||||
_ = self;
|
||||
/// Measure latency to a single URL using connection reuse method
|
||||
/// First request establishes HTTPS connection, second request measures pure RTT
|
||||
fn measureSingleUrl(self: *Self, url: []const u8) !f64 {
|
||||
var client = http.Client{ .allocator = self.allocator };
|
||||
defer client.deinit();
|
||||
|
||||
// Parse URL
|
||||
const uri = try std.Uri.parse(url);
|
||||
|
||||
// Measure request/response timing
|
||||
// First request: Establish HTTPS connection (ignore timing)
|
||||
{
|
||||
const server_header_buffer = try self.allocator.alloc(u8, 4096);
|
||||
defer self.allocator.free(server_header_buffer);
|
||||
|
||||
var req = try client.open(.HEAD, uri, .{
|
||||
.server_header_buffer = server_header_buffer,
|
||||
});
|
||||
defer req.deinit();
|
||||
|
||||
try req.send();
|
||||
try req.finish();
|
||||
try req.wait();
|
||||
}
|
||||
|
||||
// Second request: Reuse connection and measure pure HTTP RTT
|
||||
const start_time = std.time.nanoTimestamp();
|
||||
|
||||
_ = try client.fetch(.{
|
||||
.method = .HEAD,
|
||||
.location = .{ .uri = uri },
|
||||
{
|
||||
const server_header_buffer = try self.allocator.alloc(u8, 4096);
|
||||
defer self.allocator.free(server_header_buffer);
|
||||
|
||||
var req = try client.open(.HEAD, uri, .{
|
||||
.server_header_buffer = server_header_buffer,
|
||||
});
|
||||
defer req.deinit();
|
||||
|
||||
try req.send();
|
||||
try req.finish();
|
||||
try req.wait();
|
||||
}
|
||||
|
||||
const end_time = std.time.nanoTimestamp();
|
||||
|
||||
|
|
|
|||
|
|
@ -154,7 +154,7 @@ pub const HTTPSpeedTester = struct {
|
|||
|
||||
// Main measurement loop
|
||||
while (strategy.shouldContinue(timer.timer_interface().read())) {
|
||||
std.Thread.sleep(strategy.getSleepInterval());
|
||||
std.time.sleep(strategy.getSleepInterval());
|
||||
|
||||
if (has_progress) {
|
||||
const current_bytes = worker_manager.getCurrentDownloadBytes(workers);
|
||||
|
|
@ -221,7 +221,7 @@ pub const HTTPSpeedTester = struct {
|
|||
|
||||
// Main measurement loop
|
||||
while (strategy.shouldContinue(timer.timer_interface().read())) {
|
||||
std.Thread.sleep(strategy.getSleepInterval());
|
||||
std.time.sleep(strategy.getSleepInterval());
|
||||
|
||||
if (has_progress) {
|
||||
const current_bytes = worker_manager.getCurrentUploadBytes(workers);
|
||||
|
|
@ -285,7 +285,7 @@ pub const HTTPSpeedTester = struct {
|
|||
|
||||
// Main measurement loop
|
||||
while (strategy.shouldContinue(timer.timer_interface().read())) {
|
||||
std.Thread.sleep(strategy.getSleepInterval());
|
||||
std.time.sleep(strategy.getSleepInterval());
|
||||
|
||||
const current_bytes = worker_manager.getCurrentDownloadBytes(workers);
|
||||
|
||||
|
|
@ -359,7 +359,7 @@ pub const HTTPSpeedTester = struct {
|
|||
|
||||
// Main measurement loop
|
||||
while (strategy.shouldContinue(timer.timer_interface().read())) {
|
||||
std.Thread.sleep(strategy.getSleepInterval());
|
||||
std.time.sleep(strategy.getSleepInterval());
|
||||
|
||||
const current_bytes = worker_manager.getCurrentUploadBytes(workers);
|
||||
|
||||
|
|
|
|||
|
|
@ -31,7 +31,6 @@ pub const StabilityStrategy = struct {
|
|||
last_sample_time: u64 = 0,
|
||||
last_total_bytes: u64 = 0,
|
||||
consecutive_stable_checks: u32 = 0,
|
||||
allocator: std.mem.Allocator,
|
||||
|
||||
pub fn init(allocator: std.mem.Allocator, criteria: StabilityCriteria) StabilityStrategy {
|
||||
return StabilityStrategy{
|
||||
|
|
@ -39,13 +38,12 @@ pub const StabilityStrategy = struct {
|
|||
.ramp_up_duration_ns = @as(u64, criteria.ramp_up_duration_seconds) * std.time.ns_per_s,
|
||||
.max_duration_ns = @as(u64, criteria.max_duration_seconds) * std.time.ns_per_s,
|
||||
.measurement_interval_ns = criteria.measurement_interval_ms * std.time.ns_per_ms,
|
||||
.speed_measurements = std.ArrayList(f64).empty,
|
||||
.allocator = allocator,
|
||||
.speed_measurements = std.ArrayList(f64).init(allocator),
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: *StabilityStrategy) void {
|
||||
self.speed_measurements.deinit(self.allocator);
|
||||
self.speed_measurements.deinit();
|
||||
}
|
||||
|
||||
pub fn shouldContinue(self: StabilityStrategy, current_time: u64) bool {
|
||||
|
|
@ -71,7 +69,7 @@ pub const StabilityStrategy = struct {
|
|||
|
||||
// Phase 1: Ramp-up - collect measurements but don't check stability
|
||||
if (current_time < self.ramp_up_duration_ns) {
|
||||
try self.speed_measurements.append(self.allocator, interval_speed);
|
||||
try self.speed_measurements.append(interval_speed);
|
||||
|
||||
// Keep sliding window size
|
||||
if (self.speed_measurements.items.len > self.criteria.sliding_window_size) {
|
||||
|
|
@ -79,7 +77,7 @@ pub const StabilityStrategy = struct {
|
|||
}
|
||||
} else {
|
||||
// Phase 2: Stabilization - check CoV for stability
|
||||
try self.speed_measurements.append(self.allocator, interval_speed);
|
||||
try self.speed_measurements.append(interval_speed);
|
||||
|
||||
// Maintain sliding window
|
||||
if (self.speed_measurements.items.len > self.criteria.sliding_window_size) {
|
||||
|
|
|
|||
|
|
@ -169,7 +169,7 @@ pub const DownloadWorker = struct {
|
|||
_ = self.error_count.fetchAdd(1, .monotonic);
|
||||
break;
|
||||
}
|
||||
std.Thread.sleep(std.time.ns_per_ms * 100);
|
||||
std.time.sleep(std.time.ns_per_ms * 100);
|
||||
continue;
|
||||
};
|
||||
defer response.deinit();
|
||||
|
|
@ -183,7 +183,7 @@ pub const DownloadWorker = struct {
|
|||
// Accept both 200 (full content) and 206 (partial content)
|
||||
if (response.status != .ok and response.status != .partial_content) {
|
||||
print("Worker {} HTTP error: {}\n", .{ self.config.worker_id, response.status });
|
||||
std.Thread.sleep(std.time.ns_per_ms * 100);
|
||||
std.time.sleep(std.time.ns_per_ms * 100);
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -196,7 +196,7 @@ pub const DownloadWorker = struct {
|
|||
|
||||
// Small delay between requests
|
||||
if (self.config.delay_between_requests_ms > 0) {
|
||||
std.Thread.sleep(std.time.ns_per_ms * self.config.delay_between_requests_ms);
|
||||
std.time.sleep(std.time.ns_per_ms * self.config.delay_between_requests_ms);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -318,7 +318,7 @@ pub const UploadWorker = struct {
|
|||
_ = self.error_count.fetchAdd(1, .monotonic);
|
||||
break;
|
||||
}
|
||||
std.Thread.sleep(std.time.ns_per_ms * 100);
|
||||
std.time.sleep(std.time.ns_per_ms * 100);
|
||||
continue;
|
||||
};
|
||||
defer response.deinit();
|
||||
|
|
@ -331,7 +331,7 @@ pub const UploadWorker = struct {
|
|||
|
||||
if (response.status != .ok) {
|
||||
print("Upload worker {} HTTP error: {}\n", .{ self.config.worker_id, response.status });
|
||||
std.Thread.sleep(std.time.ns_per_ms * 100);
|
||||
std.time.sleep(std.time.ns_per_ms * 100);
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -404,14 +404,15 @@ pub const RealHttpClient = struct {
|
|||
fn fetch(ptr: *anyopaque, request: FetchRequest) !FetchResponse {
|
||||
const self: *Self = @ptrCast(@alignCast(ptr));
|
||||
|
||||
var response_body = std.Io.Writer.Allocating.init(self.allocator);
|
||||
var response_body = std.ArrayList(u8).init(self.allocator);
|
||||
errdefer response_body.deinit();
|
||||
|
||||
const fetch_options = http.Client.FetchOptions{
|
||||
.method = request.method,
|
||||
.location = .{ .url = request.url },
|
||||
.payload = if (request.payload) |p| p else null,
|
||||
.response_writer = &response_body.writer,
|
||||
.response_storage = .{ .dynamic = &response_body },
|
||||
.max_append_size = request.max_response_size,
|
||||
};
|
||||
|
||||
const result = try self.client.fetch(fetch_options);
|
||||
|
|
@ -468,7 +469,7 @@ pub const MockHttpClient = struct {
|
|||
pub fn init(allocator: std.mem.Allocator) Self {
|
||||
return Self{
|
||||
.allocator = allocator,
|
||||
.responses = std.ArrayList(FetchResponse).empty,
|
||||
.responses = std.ArrayList(FetchResponse).init(allocator),
|
||||
.request_count = std.atomic.Value(u32).init(0),
|
||||
};
|
||||
}
|
||||
|
|
@ -477,12 +478,12 @@ pub const MockHttpClient = struct {
|
|||
for (self.responses.items) |*response| {
|
||||
self.allocator.free(response.body);
|
||||
}
|
||||
self.responses.deinit(self.allocator);
|
||||
self.responses.deinit();
|
||||
}
|
||||
|
||||
pub fn addResponse(self: *Self, status: http.Status, body: []const u8) !void {
|
||||
const body_copy = try self.allocator.dupe(u8, body);
|
||||
try self.responses.append(self.allocator, FetchResponse{
|
||||
try self.responses.append(FetchResponse{
|
||||
.status = status,
|
||||
.body = body_copy,
|
||||
.allocator = self.allocator,
|
||||
|
|
@ -504,7 +505,7 @@ pub const MockHttpClient = struct {
|
|||
_ = request;
|
||||
|
||||
if (self.delay_ms > 0) {
|
||||
std.Thread.sleep(std.time.ns_per_ms * self.delay_ms);
|
||||
std.time.sleep(std.time.ns_per_ms * self.delay_ms);
|
||||
}
|
||||
|
||||
if (self.should_fail) {
|
||||
|
|
@ -610,7 +611,7 @@ test "DownloadWorker basic functionality" {
|
|||
const thread = try std.Thread.spawn(.{}, DownloadWorker.run, .{&worker});
|
||||
|
||||
// Let it run for a bit
|
||||
std.Thread.sleep(std.time.ns_per_ms * 100);
|
||||
std.time.sleep(std.time.ns_per_ms * 100);
|
||||
|
||||
// Advance timer to trigger stop
|
||||
mock_timer.setTime(std.time.ns_per_s * 3); // 3 seconds
|
||||
|
|
|
|||
|
|
@ -1,5 +1,4 @@
|
|||
const std = @import("std");
|
||||
|
||||
const cli = @import("cli/root.zig");
|
||||
|
||||
pub const std_options: std.Options = .{
|
||||
|
|
@ -11,12 +10,8 @@ pub const std_options: std.Options = .{
|
|||
};
|
||||
|
||||
pub fn main() !void {
|
||||
const allocator = std.heap.smp_allocator;
|
||||
|
||||
const file = std.fs.File.stdout();
|
||||
var writer = file.writerStreaming(&.{}).interface;
|
||||
|
||||
const root = try cli.build(&writer, allocator);
|
||||
const allocator = std.heap.page_allocator;
|
||||
var root = try cli.build(allocator);
|
||||
defer root.deinit();
|
||||
|
||||
try root.execute(.{});
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue