hax/fast-cli
1
0
Fork 0
mirror of https://github.com/mikkelam/fast-cli.git synced 2025-12-18 12:54:05 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

clean unused code

Browse source
This commit is contained in:
mikkelam 2025-06-19 14:01:54 +02:00
parent 8000eb850d
commit e7e1efbd57
4 changed files with 20 additions and 48 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/cli/root.zig
View file

@ -58,7 +58,7 @@ 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,
.version = null,
}, run);
try root.addFlag(https_flag);

11
src/lib/bandwidth.zig
View file

@ -41,11 +41,6 @@ pub const BandwidthMeter = struct {
self._bytes_transferred = total_bytes;
}
pub fn record_bytes(self: *BandwidthMeter, byte_count: usize) void {
assert(self._started);
self._bytes_transferred += byte_count;
}
pub fn bandwidth(self: *BandwidthMeter) f64 {
if (!self._started) return 0;
@ -97,8 +92,8 @@ test "BandwidthMeter record_bytes" {
var meter = BandwidthMeter.init();
try meter.start();
meter.record_bytes(1000);
meter.record_bytes(500);
meter.update_total(1000);
meter.update_total(1500);
// Just test that bandwidth calculation works
const bw = meter.bandwidth();
@ -109,7 +104,7 @@ test "BandwidthMeter bandwidth calculation" {
var meter = BandwidthMeter.init();
try meter.start();
meter.record_bytes(1000); // 1000 bytes
meter.update_total(1000); // 1000 bytes
// Sleep briefly to ensure time passes
std.time.sleep(std.time.ns_per_ms * 10); // 10ms

50
src/lib/http_speed_tester_v2.zig
View file

@ -15,9 +15,9 @@ pub const SpeedTestResult = struct {
speed: SpeedMeasurement,
/// Convert bytes per second to optimal unit for display (in bits per second)
pub fn fromBytesPerSecond(speed_bytes_per_sec: f64) SpeedTestResult {
pub fn fromBytesPerSecond(bytes_per_second: f64) SpeedTestResult {
// Convert bytes/s to bits/s
const speed_bits_per_sec = speed_bytes_per_sec * 8.0;
const speed_bits_per_sec = bytes_per_second * 8.0;
const abs_speed = @abs(speed_bits_per_sec);
const speed_measurement = if (abs_speed >= 1_000_000_000)
@ -50,20 +50,6 @@ pub const HTTPSpeedTester = struct {
_ = self;
}
pub fn set_concurrent_connections(self: *HTTPSpeedTester, count: u32) void {
self.concurrent_connections = @min(count, 8); // Max 8 connections
}
pub fn set_progress_update_interval_ms(self: *HTTPSpeedTester, interval_ms: u32) void {
self.progress_update_interval_ms = interval_ms;
}
// Clean duration-based download with optional progress callback
pub fn measure_download_speed_duration(self: *HTTPSpeedTester, urls: []const []const u8, duration_seconds: u32, comptime ProgressType: ?type, progress_callback: if (ProgressType) |T| T else void) !SpeedTestResult {
const strategy = measurement_strategy.createDurationStrategy(duration_seconds, self.progress_update_interval_ms);
return self.measureDownloadSpeedWithDuration(urls, strategy, ProgressType, progress_callback);
}
// Fast.com-style stability-based download with optional progress callback
pub fn measure_download_speed_fast_stability_duration(self: *HTTPSpeedTester, urls: []const []const u8, criteria: StabilityCriteria, comptime ProgressType: ?type, progress_callback: if (ProgressType) |T| T else void) !SpeedTestResult {
var strategy = measurement_strategy.createStabilityStrategy(self.allocator, criteria);
@ -76,16 +62,6 @@ pub const HTTPSpeedTester = struct {
return self.measure_download_speed_fast_stability_duration(urls, criteria, null, {});
}
// Clean duration-based upload with optional progress callback
pub fn measure_upload_speed_duration(self: *HTTPSpeedTester, urls: []const []const u8, duration_seconds: u32, comptime ProgressType: ?type, progress_callback: if (ProgressType) |T| T else void) !SpeedTestResult {
const upload_data = try self.allocator.alloc(u8, 4 * 1024 * 1024);
defer self.allocator.free(upload_data);
@memset(upload_data, 'A');
const strategy = measurement_strategy.createDurationStrategy(duration_seconds, self.progress_update_interval_ms);
return self.measureUploadSpeedWithDuration(urls, strategy, upload_data, ProgressType, progress_callback);
}
// Fast.com-style stability-based upload with optional progress callback
pub fn measure_upload_speed_fast_stability_duration(self: *HTTPSpeedTester, urls: []const []const u8, criteria: StabilityCriteria, comptime ProgressType: ?type, progress_callback: if (ProgressType) |T| T else void) !SpeedTestResult {
const upload_data = try self.allocator.alloc(u8, 4 * 1024 * 1024);
@ -104,14 +80,25 @@ pub const HTTPSpeedTester = struct {
// Convenience helpers for cleaner API usage
// Clean duration-based download with optional progress callback
pub fn measure_download_speed_duration(self: *HTTPSpeedTester, urls: []const []const u8, duration_seconds: u32, comptime ProgressType: ?type, progress_callback: if (ProgressType) |T| T else void) !SpeedTestResult {
const strategy = measurement_strategy.createDurationStrategy(duration_seconds, self.progress_update_interval_ms);
return self.measureDownloadSpeedWithDuration(urls, strategy, ProgressType, progress_callback);
}
/// Simple download speed measurement without progress callback
pub fn measureDownloadSpeed(self: *HTTPSpeedTester, urls: []const []const u8, duration_seconds: u32) !SpeedTestResult {
return self.measure_download_speed_duration(urls, duration_seconds, null, {});
}
/// Download speed measurement with progress callback (type inferred)
pub fn measureDownloadSpeedWithProgress(self: *HTTPSpeedTester, urls: []const []const u8, duration_seconds: u32, progress_callback: anytype) !SpeedTestResult {
return self.measure_download_speed_duration(urls, duration_seconds, @TypeOf(progress_callback), progress_callback);
// Clean duration-based upload with optional progress callback
pub fn measure_upload_speed_duration(self: *HTTPSpeedTester, urls: []const []const u8, duration_seconds: u32, comptime ProgressType: ?type, progress_callback: if (ProgressType) |T| T else void) !SpeedTestResult {
const upload_data = try self.allocator.alloc(u8, 4 * 1024 * 1024);
defer self.allocator.free(upload_data);
@memset(upload_data, 'A');
const strategy = measurement_strategy.createDurationStrategy(duration_seconds, self.progress_update_interval_ms);
return self.measureUploadSpeedWithDuration(urls, strategy, upload_data, ProgressType, progress_callback);
}
/// Simple upload speed measurement without progress callback
@ -119,11 +106,6 @@ pub const HTTPSpeedTester = struct {
return self.measure_upload_speed_duration(urls, duration_seconds, null, {});
}
/// Upload speed measurement with progress callback (type inferred)
pub fn measureUploadSpeedWithProgress(self: *HTTPSpeedTester, urls: []const []const u8, duration_seconds: u32, progress_callback: anytype) !SpeedTestResult {
return self.measure_upload_speed_duration(urls, duration_seconds, @TypeOf(progress_callback), progress_callback);
}
/// Fast stability download speed measurement with progress callback (type inferred)
pub fn measureDownloadSpeedWithFastStabilityProgress(self: *HTTPSpeedTester, urls: []const []const u8, criteria: StabilityCriteria, progress_callback: anytype) !SpeedTestResult {
return self.measure_download_speed_fast_stability_duration(urls, criteria, @TypeOf(progress_callback), progress_callback);

5
src/lib/progress.zig
View file

@ -29,8 +29,3 @@ pub fn createCallback(context: anytype, comptime updateFn: anytype) ProgressCall
.updateFn = wrapper.call,
};
}
/// Check if a value is a valid progress callback at comptime
pub fn isProgressCallback(comptime T: type) bool {
return @hasDecl(T, "call") and @hasField(T, "context");
}