X-Git-Url: https://git.xandkar.net/?a=blobdiff_plain;f=v2%2Fsrc%2Fawk%2Flib%2Fcache.awk;fp=v2%2Fsrc%2Fawk%2Flib%2Fcache.awk;h=a2dd879c5101edefbefc9ee6c48ca5bbc8f79fcf;hb=53d24ad688ea39892dbf3c748c1e40514eeb2763;hp=0000000000000000000000000000000000000000;hpb=0c4f892ec9d0cd7dc87c83c01b52259d0aed1ae3;p=khatus.git

diff --git a/v2/src/awk/lib/cache.awk b/v2/src/awk/lib/cache.awk
new file mode 100644
index 0000000..a2dd879
--- /dev/null
+++ b/v2/src/awk/lib/cache.awk
@@ -0,0 +1,110 @@
+# Naming convention:
+#     Variables:
+#         - global, builtin : ALLCAPS
+#         - global, public  : Camel_Snake_Man_Bear_Pig
+#         - global, private : _snake_case_prefixed_underscore
+#         - local           : snake_case
+#     Functions:
+#         - global, public  : snake_case
+
+BEGIN {
+    GC_Interval = GC_Interval ? GC_Interval : 3600  # seconds
+
+    _total_to_diff["khatus_sensor_net_addr_io", "bytes_read"     ] = 1
+    _total_to_diff["khatus_sensor_net_addr_io", "bytes_written"  ] = 1
+    _total_to_diff["khatus_sensor_disk_io"    , "sectors_read"   ] = 1
+    _total_to_diff["khatus_sensor_disk_io"    , "sectors_written"] = 1
+
+    # (x * y) / z = x * w
+    #   ==> w = y / z
+    # (x * bytes_per_sector) / bytes_per_mb = x * scaling_factor
+    #   ==> scaling_factor = bytes_per_sector / bytes_per_mb
+    _bytes_per_sector = 512
+    _bytes_per_mb     = 1024 * 1024
+    _scale["khatus_sensor_disk_io", "sectors_written"] = _bytes_per_sector / _bytes_per_mb
+    _scale["khatus_sensor_disk_io", "sectors_read"   ] = _bytes_per_sector / _bytes_per_mb
+    # (x / y) = x * z
+    #   ==> z = 1 / y
+    # x / bytes_per_mb = x * scaling_factor
+    #   ==> scaling_factor = 1 / bytes_per_mb
+    _scale["khatus_sensor_net_addr_io", "bytes_written"] = 1 / _bytes_per_mb
+    _scale["khatus_sensor_net_addr_io", "bytes_read"   ] = 1 / _bytes_per_mb
+}
+
+function cache_update(node, module, key, val,    time) {
+    # TODO: Use node value
+    val = cache_maybe_total_to_diff(module, key, val)
+    val = cache_maybe_scale(module, key, val)
+    _cache[module, key] = val
+    time = cache_get_time()
+    _cache_mtime[module, key] = time
+    if (time % GC_Interval == 0) {
+        cache_gc()
+    }
+}
+
+function cache_get(result, module, key, ttl,    time, age, is_expired) {
+    time = cache_get_time()
+    _cache_atime[module, key] = time
+    age = time - _cache_mtime[module, key]
+    result["is_expired"] = ttl && age > ttl  # ttl = 0 => forever
+    result["value"] = _cache[module, key]
+}
+
+function cache_res_fmt_or_def(result, format, default) {
+    return result["is_expired"] ? default : sprintf(format, result["value"])
+}
+
+function cache_get_fmt_def(module, key, ttl, format, default,    result) {
+    default = default ? default : "--"
+    cache_get(result, module, key, ttl)
+    return cache_res_fmt_or_def(result, format, default)
+}
+
+function cache_get_time(    module, key, time) {
+    module = "khatus_sensor_datetime"
+    key = "epoch"
+    time = _cache[module, key]
+    _cache_atime[module, key] = time
+    return time
+}
+
+function cache_gc(    module_and_key, parts, module, key, unused_for) {
+    for (module_and_key in _cache) {
+        split(module_and_key, parts, SUBSEP)
+        module = parts[1]
+        key = parts[2]
+        val = _cache[module, key]
+        unused_for = cache_get_time() - _cache_atime[module, key]
+        if (unused_for > GC_Interval) {
+            msg_out_log_info(\
+                "cache_gc",
+                sprintf(\
+                    "Deleting unused data MODULE=%s KEY=%s VAL=%s",
+                    module, key, val\
+                ) \
+            )
+            delete _cache[module, key]
+        }
+    }
+}
+
+function cache_maybe_total_to_diff(module, key, val,    key_parts) {
+    split(key, key_parts, Kfs)
+    if (_total_to_diff[module, key_parts[1]]) {
+        _prev[module, key] = _curr[module, key]
+        _curr[module, key] = val
+        return (_curr[module, key] - _prev[module, key])
+    } else {
+        return val
+    }
+}
+
+function cache_maybe_scale(module, key, val,    key_parts) {
+    split(key, key_parts, Kfs)
+    if ((module SUBSEP key_parts[1]) in _scale) {
+        return val * _scale[module, key_parts[1]]
+    } else {
+        return val
+    }
+}