lobo/wttr
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Compare commits

base: lobo:1e6a5e28ca3e8ca11426264c80adc748225819fc
Branches Tags
lobo:master
..
compare: lobo:456057a2c054cf8ff5d1e1ed2e004d531405bff5
Branches Tags
lobo:master

No commits in common. "1e6a5e28ca3e8ca11426264c80adc748225819fc" and "456057a2c054cf8ff5d1e1ed2e004d531405bff5" have entirely different histories.
1e6a5e28ca ... 456057a2c0

10 changed files with 106 additions and 169 deletions
Show stats Expand all files Collapse all files

19
src/cache/Cache.zig vendored
View file

@ -49,7 +49,8 @@ pub fn get(self: *Cache, key: []const u8) ?[]const u8 {
// Check L2 (disk)
const cached = self.loadFromFile(key) catch return null;
defer cached.deinit(self.allocator);
defer self.allocator.free(cached.key);
defer self.allocator.free(cached.value);
// L2 exists - promote to L1
self.lru.put(key, cached.value, cached.expires) catch return null;
@ -85,11 +86,6 @@ const CacheEntry = struct {
key: []const u8,
value: []const u8,
expires: i64,
pub fn deinit(self: CacheEntry, allocator: std.mem.Allocator) void {
allocator.free(self.key);
allocator.free(self.value);
}
};
/// Loads cached value from file (path calculated by the key). An error will be thrown
@ -117,7 +113,7 @@ fn loadFromFilePath(self: *Cache, file_path: []const u8) !CacheEntry {
const reader = &file_reader.interface;
const cached = try deserialize(self.allocator, reader);
errdefer cached.deinit(self.allocator);
errdefer self.allocator.free(cached.value);
// Check if expired
const now = std.time.milliTimestamp();
@ -183,7 +179,8 @@ fn loadFromDir(self: *Cache) !void {
defer self.allocator.free(file_path);
const cached = self.loadFromFilePath(file_path) catch continue;
defer cached.deinit(self.allocator);
defer self.allocator.free(cached.key);
defer self.allocator.free(cached.value);
// Populate L1 cache from L2
self.lru.put(cached.key, cached.value, cached.expires) catch continue;
@ -221,7 +218,8 @@ test "serialize and deserialize" {
var fixed_reader = std.Io.Reader.fixed(serialized);
const cached = try deserialize(allocator, &fixed_reader);
defer cached.deinit(allocator);
defer allocator.free(cached.key);
defer allocator.free(cached.value);
try std.testing.expectEqualStrings(key, cached.key);
try std.testing.expectEqualStrings(value, cached.value);
@ -236,7 +234,8 @@ test "deserialize handles integer expires" {
var fixed_reader = std.Io.Reader.fixed(json);
const cached = try deserialize(allocator, &fixed_reader);
defer cached.deinit(allocator);
defer allocator.free(cached.key);
defer allocator.free(cached.value);
try std.testing.expectEqualStrings("k", cached.key);
try std.testing.expectEqualStrings("v", cached.value);

4
src/http/Server.zig
View file

@ -121,8 +121,10 @@ const MockHarness = struct {
const geoip = try allocator.create(GeoIp);
errdefer allocator.destroy(geoip);
geoip.* = GeoIp.init(allocator, config.geolite_path, null, config.ip2location_cache_file) catch
geoip.* = GeoIp.init(allocator, config.geolite_path, null, null) catch {
allocator.destroy(geoip);
return error.SkipZigTest;
};
errdefer geoip.deinit();
var geocache = try allocator.create(GeoCache);

BIN
src/http/favicon.ico
View file

Binary file not shown.
Side by side

Before

Width:  |  Height:  |  Size: 291 B

75
src/http/handler.zig
View file

@ -48,11 +48,7 @@ pub fn handleWeather(
break :blk loc;
} else break :blk client_ip; // no location, just use client ip instead
};
if (std.mem.eql(u8, "favicon.ico", location)) {
res.header("Content-Type", "image/x-icon");
res.body = @embedFile("favicon.ico");
return;
}
log.debug("location = {s}, client_ip = {s}", .{ location, client_ip });
if (location.len == 0) {
res.content_type = .TEXT;
@ -168,64 +164,27 @@ fn handleWeatherInternal(
break :blk false;
};
const output = if (params.format) |fmt| blk: {
if (std.mem.eql(u8, fmt, "j1")) {
res.content_type = .JSON;
break :blk try json.render(req_alloc, weather);
}
if (std.mem.eql(u8, fmt, "v2"))
break :blk try v2.render(req_alloc, weather, use_imperial);
if (std.mem.startsWith(u8, fmt, "%"))
break :blk try custom.render(req_alloc, weather, fmt, use_imperial);
// fall back to line if we don't understant the format parameter
break :blk try line.render(req_alloc, weather, fmt, use_imperial);
} else try formatted.render(req_alloc, weather, .{ .use_imperial = use_imperial });
// Add coordinates header using response allocator
const coords_header = try std.fmt.allocPrint(res.arena, "{d:.4},{d:.4}", .{ location.coords.latitude, location.coords.longitude });
res.headers.add("X-Location-Coordinates", coords_header);
res.body = blk: {
if (params.format) |fmt| {
// Anything except the json will be plain text
res.content_type = .TEXT;
if (std.mem.eql(u8, fmt, "j1")) {
res.content_type = .JSON; // reset to json
break :blk try json.render(req_alloc, weather);
}
if (std.mem.eql(u8, fmt, "v2"))
break :blk try v2.render(req_alloc, weather, use_imperial);
if (std.mem.startsWith(u8, fmt, "%"))
break :blk try custom.render(req_alloc, weather, fmt, use_imperial);
// fall back to line if we don't understand the format parameter
break :blk try line.render(req_alloc, weather, fmt, use_imperial);
} else {
const format: formatted.Format = determineFormat(params, req.headers.get("user-agent"));
log.debug(
"Format: {}. params.ansi {}, params.text {}, user agent: {?s}",
.{ format, params.ansi, params.text_only, req.headers.get("user-agent") },
);
if (format != .html) res.content_type = .TEXT else res.content_type = .HTML;
break :blk try formatted.render(req_alloc, weather, .{ .use_imperial = use_imperial, .format = format });
}
};
}
if (res.content_type != .JSON)
res.content_type = .TEXT;
fn determineFormat(params: QueryParams, user_agent: ?[]const u8) formatted.Format {
if (params.ansi or params.text_only) {
// user explicitly requested something. If both are set, text will win
if (params.text_only) return .plain_text;
return .ansi;
}
const ua = user_agent orelse "";
// https://github.com/chubin/wttr.in/blob/master/lib/globals.py#L82C1-L97C2
const plain_text_agents = &[_][]const u8{
"curl",
"httpie",
"lwp-request",
"wget",
"python-requests",
"python-httpx",
"openbsd ftp",
"powershell",
"fetch",
"aiohttp",
"http_get",
"xh",
"nushell",
"zig",
};
for (plain_text_agents) |agent|
if (std.mem.indexOf(u8, ua, agent)) |_|
return .ansi;
return .html;
res.body = output;
}
test "parseXForwardedFor extracts first IP" {

39
src/http/query.zig
View file

@ -1,33 +1,11 @@
const std = @import("std");
///Units:
///
/// m # metric (SI) (used by default everywhere except US)
/// u # USCS (used by default in US)
/// M # show wind speed in m/s
///
///View options:
///
/// 0 # only current weather
/// 1 # current weather + today's forecast
/// 2 # current weather + today's + tomorrow's forecast
/// A # ignore User-Agent and force ANSI output format (terminal)
/// d # restrict output to standard console font glyphs
/// F # do not show the "Follow" line
/// n # narrow version (only day and night)
/// q # quiet version (no "Weather report" text)
/// Q # superquiet version (no "Weather report", no city name)
/// T # switch terminal sequences off (no colors)
pub const QueryParams = struct {
format: ?[]const u8 = null,
lang: ?[]const u8 = null,
location: ?[]const u8 = null,
units: ?Units = null,
transparency: ?u8 = null,
/// A: Ignore user agent and force ansi mode
ansi: bool = false,
/// T: Avoid terminal sequences and just output plain text
text_only: bool = false,
pub const Units = enum {
metric,
@ -45,22 +23,16 @@ pub const QueryParams = struct {
const key = kv.next() orelse continue;
const value = kv.next();
if (key.len == 1) {
switch (key[0]) {
'u' => params.units = .uscs,
'm' => params.units = .metric,
'A' => params.ansi = true,
'T' => params.text_only = true,
't' => params.transparency = 150,
else => continue,
}
}
if (std.mem.eql(u8, key, "format")) {
params.format = if (value) |v| try allocator.dupe(u8, v) else null;
} else if (std.mem.eql(u8, key, "lang")) {
params.lang = if (value) |v| try allocator.dupe(u8, v) else null;
} else if (std.mem.eql(u8, key, "location")) {
params.location = if (value) |v| try allocator.dupe(u8, v) else null;
} else if (std.mem.eql(u8, key, "u")) {
params.units = .uscs;
} else if (std.mem.eql(u8, key, "m")) {
params.units = .metric;
} else if (std.mem.eql(u8, key, "use_imperial")) {
params.units = .uscs;
} else if (std.mem.eql(u8, key, "use_metric")) {
@ -69,6 +41,8 @@ pub const QueryParams = struct {
if (value) |v| {
params.transparency = try std.fmt.parseInt(u8, v, 10);
}
} else if (std.mem.eql(u8, key, "t")) {
params.transparency = 150;
}
}
@ -134,7 +108,6 @@ test "parse multiple parameters" {
test "parse transparency" {
const allocator = std.testing.allocator;
const params_t = try QueryParams.parse(allocator, "t");
try std.testing.expect(params_t.transparency != null);
try std.testing.expectEqual(@as(u8, 150), params_t.transparency.?);
const params_custom = try QueryParams.parse(allocator, "transparency=200");

64
src/location/GeoIp.zig
View file

@ -10,10 +10,11 @@ const GeoIP = @This();
const log = std.log.scoped(.geoip);
mmdb: *c.MMDB_s,
ip2location_client: *Ip2location,
ip2location_client: ?*Ip2location,
ip2location_cache: ?*Ip2location.Cache,
allocator: std.mem.Allocator,
pub fn init(allocator: std.mem.Allocator, db_path: []const u8, api_key: ?[]const u8, cache_path: []const u8) !GeoIP {
pub fn init(allocator: std.mem.Allocator, db_path: []const u8, api_key: ?[]const u8, cache_path: ?[]const u8) !GeoIP {
const path_z = try std.heap.c_allocator.dupeZ(u8, db_path);
defer std.heap.c_allocator.free(path_z);
@ -21,25 +22,32 @@ pub fn init(allocator: std.mem.Allocator, db_path: []const u8, api_key: ?[]const
errdefer allocator.destroy(mmdb);
const status = c.MMDB_open(path_z.ptr, c.MMDB_MODE_MMAP, mmdb);
if (status != c.MMDB_SUCCESS)
if (status != c.MMDB_SUCCESS) {
return error.CannotOpenDatabase;
const client: *Ip2location = try allocator.create(Ip2location);
errdefer allocator.destroy(client);
client.* = try Ip2location.init(allocator, api_key, cache_path);
errdefer {
client.deinit();
allocator.destroy(client);
}
std.log.info(
"IP2Location fallback: {s} (cache: {s})",
.{ if (api_key) |_| "key provided, 50k/mo limit" else "no key, 1k/day limit", cache_path },
);
var client: ?*Ip2location = null;
var cache: ?*Ip2location.Cache = null;
if (api_key) |key| {
client = try allocator.create(Ip2location);
client.?.* = try Ip2location.init(allocator, key);
if (cache_path) |path| {
cache = try allocator.create(Ip2location.Cache);
cache.?.* = try Ip2location.Cache.init(allocator, path);
std.log.info("IP2Location fallback: enabled (cache: {s})", .{path});
} else {
std.log.info("IP2Location fallback: enabled (no cache)", .{});
}
} else {
std.log.info("IP2Location fallback: disabled (no API key configured)", .{});
}
return GeoIP{
.mmdb = mmdb,
.ip2location_client = client,
.ip2location_cache = cache,
.allocator = allocator,
};
}
@ -47,9 +55,14 @@ pub fn init(allocator: std.mem.Allocator, db_path: []const u8, api_key: ?[]const
pub fn deinit(self: *GeoIP) void {
c.MMDB_close(self.mmdb);
self.allocator.destroy(self.mmdb);
self.ip2location_client.deinit();
log.debug("destroying client", .{});
self.allocator.destroy(self.ip2location_client);
if (self.ip2location_client) |client| {
client.deinit();
self.allocator.destroy(client);
}
if (self.ip2location_cache) |cache| {
cache.deinit();
self.allocator.destroy(cache);
}
}
pub fn lookup(self: *GeoIP, ip: []const u8) ?Coordinates {
@ -61,8 +74,11 @@ pub fn lookup(self: *GeoIP, ip: []const u8) ?Coordinates {
if (self.extractCoordinates(ip, result)) |coords|
return coords;
// Fallback to IP2Location
return self.ip2location_client.lookup(ip);
// Fallback to IP2Location if configured
if (self.ip2location_client) |client|
return client.lookupWithCache(ip, self.ip2location_cache);
return null;
}
fn lookupInternal(mmdb: *c.MMDB_s, ip: []const u8) !c.MMDB_lookup_result_s {
@ -145,11 +161,11 @@ test "MMDB functions are callable" {
}
test "GeoIP init with invalid path fails" {
const result = GeoIP.init(std.testing.allocator, "/nonexistent/path.mmdb", null, "");
const result = GeoIP.init(std.testing.allocator, "/nonexistent/path.mmdb", null, null);
try std.testing.expectError(error.CannotOpenDatabase, result);
}
test "isUSIp detects US IPs" {
test "isUSIP detects US IPs" {
const allocator = std.testing.allocator;
const Config = @import("../Config.zig");
const config = try Config.load(allocator);
@ -162,8 +178,9 @@ test "isUSIp detects US IPs" {
try GeoLite2.ensureDatabase(std.testing.allocator, db_path);
}
var geoip = GeoIP.init(std.testing.allocator, db_path, null, config.ip2location_cache_file) catch
var geoip = GeoIP.init(std.testing.allocator, db_path, null, null) catch {
return error.SkipZigTest;
};
defer geoip.deinit();
// Test that the function doesn't crash with various IPs
@ -186,8 +203,9 @@ test "lookup works" {
try GeoLite2.ensureDatabase(std.testing.allocator, db_path);
}
var geoip = GeoIP.init(std.testing.allocator, db_path, null, config.ip2location_cache_file) catch
var geoip = GeoIP.init(std.testing.allocator, db_path, null, null) catch {
return error.SkipZigTest;
};
defer geoip.deinit();
// Test that the function doesn't crash with various IPs

67
src/location/Ip2location.zig
View file

@ -7,31 +7,23 @@ const Self = @This();
const log = std.log.scoped(.ip2location);
allocator: Allocator,
api_key: ?[]const u8,
api_key: []const u8,
http_client: std.http.Client,
cache: *Cache,
pub fn init(allocator: Allocator, api_key: ?[]const u8, cache_path: []const u8) !Self {
const cache = try allocator.create(Cache);
errdefer allocator.destroy(cache);
cache.* = try .init(allocator, cache_path);
pub fn init(allocator: Allocator, api_key: []const u8) !Self {
return .{
.allocator = allocator,
.api_key = if (api_key) |k| try allocator.dupe(u8, k) else null,
.api_key = try allocator.dupe(u8, api_key),
.http_client = std.http.Client{ .allocator = allocator },
.cache = cache,
};
}
pub fn deinit(self: *Self) void {
self.cache.deinit();
self.allocator.destroy(self.cache);
self.http_client.deinit();
if (self.api_key) |k|
self.allocator.free(k);
self.allocator.free(self.api_key);
}
pub fn lookup(self: *Self, ip_str: []const u8) ?Coordinates {
pub fn lookupWithCache(self: *Self, ip_str: []const u8, cache: ?*Cache) ?Coordinates {
// Parse IP to u128 for cache lookup
const addr = std.net.Address.parseIp(ip_str, 0) catch return null;
const ip_u128: u128 = switch (addr.any.family) {
@ -42,39 +34,46 @@ pub fn lookup(self: *Self, ip_str: []const u8) ?Coordinates {
const family: u8 = if (addr.any.family == std.posix.AF.INET) 4 else 6;
// Check cache first
if (self.cache.get(ip_u128)) |coords|
return coords;
if (cache) |c| {
if (c.get(ip_u128)) |coords| {
return coords;
}
}
// Fetch from API
const coords = self.fetch(ip_str) catch |err| {
const coords = self.lookup(ip_str) catch |err| {
log.err("API lookup failed: {}", .{err});
return null;
};
// Store in cache
self.cache.put(ip_u128, family, coords) catch |err| {
log.warn("Failed to cache result: {}", .{err});
};
if (cache) |c| {
c.put(ip_u128, family, coords) catch |err| {
log.warn("Failed to cache result: {}", .{err});
};
}
return coords;
}
fn fetch(self: *Self, ip_str: []const u8) !Coordinates {
pub fn lookup(self: *Self, ip_str: []const u8) !Coordinates {
log.info("Fetching geolocation for IP {s}", .{ip_str});
if (@import("builtin").is_test) return error.LookupUnavailableInUnitTest;
var buf: [256]u8 = undefined;
var w = std.Io.Writer.fixed(&buf);
// Build URL: https://api.ip2location.io/?key=XXX&ip=1.2.3.4
try w.writeAll("https://api.ip2location.io/?ip=");
try w.writeAll(ip_str);
if (self.api_key) |key|
try w.print("&key={s}", .{key});
const url = try std.fmt.allocPrint(
self.allocator,
"https://api.ip2location.io/?key={s}&ip={s}",
.{ self.api_key, ip_str },
);
defer self.allocator.free(url);
const uri = try std.Uri.parse(url);
var response_buf: [4096]u8 = undefined;
var writer = std.io.Writer.fixed(&response_buf);
const result = try self.http_client.fetch(.{
.location = .{ .url = w.buffered() },
.location = .{ .uri = uri },
.method = .GET,
.response_writer = &writer,
});
@ -98,18 +97,7 @@ fn fetch(self: *Self, ip_str: []const u8) !Coordinates {
const obj = parsed.value.object;
const lat = obj.get("latitude") orelse return error.MissingLatitude;
const lon = obj.get("longitude") orelse return error.MissingLongitude;
if (lat == .null) return error.MissingLatitude;
if (lat != .float)
log.err(
"Latitude returned from ip2location.io for ip {s} is not a float: {f}",
.{ ip_str, std.json.fmt(lat, .{}) },
);
if (lon == .null) return error.MissingLongitude;
if (lon != .float)
log.err(
"Longitude returned from ip2location.io for ip {s} is not a float: {f}",
.{ ip_str, std.json.fmt(lon, .{}) },
);
return Coordinates{
.latitude = @floatCast(lat.float),
.longitude = @floatCast(lon.float),
@ -143,7 +131,6 @@ pub const Cache = struct {
.entries = std.AutoHashMap(u128, Coordinates).init(allocator),
.file = null,
};
errdefer allocator.free(cache.path);
// Try to open existing cache file
if (std.fs.openFileAbsolute(path, .{ .mode = .read_write })) |file| {

3
src/location/resolver.zig
View file

@ -254,8 +254,9 @@ test "resolve IP address with GeoIP" {
try GeoLite2.ensureDatabase(allocator, config.geolite_path);
}
var geoip = GeoIp.init(allocator, config.geolite_path, null, config.ip2location_cache_file) catch
var geoip = GeoIp.init(allocator, config.geolite_path, null, null) catch {
return error.SkipZigTest;
};
defer geoip.deinit();
var geocache = try GeoCache.init(allocator, null);

2
src/main.zig
View file

@ -43,7 +43,7 @@ pub fn main() !u8 {
allocator,
cfg.geolite_path,
cfg.ip2location_api_key,
cfg.ip2location_cache_file,
if (cfg.ip2location_api_key != null) cfg.ip2location_cache_file else null,
) catch |err| {
std.log.err("Failed to load GeoIP database from {s}: {}", .{ cfg.geolite_path, err });
return err;

2
src/render/formatted.zig
View file

@ -110,7 +110,6 @@ pub fn render(allocator: std.mem.Allocator, data: types.WeatherData, options: Re
defer output.deinit();
const w = &output.writer;
if (options.format == .html) try w.writeAll("<pre>");
if (!options.no_caption)
try w.print("Weather report: {s}\n\n", .{data.locationDisplayName()});
@ -123,7 +122,6 @@ pub fn render(allocator: std.mem.Allocator, data: types.WeatherData, options: Re
try renderForecastDay(w, day, options);
}
}
if (options.format == .html) try w.writeAll("</pre>");
return output.toOwnedSlice();
}