bin/khatus_bar

   1 #! /usr/bin/awk -f
   2
   3 # Naming convention:
   4 #     Variables:
   5 #         - global, builtin : ALLCAPS
   6 #         - global, public  : Camel_Snake_Man_Bear_Pig
   7 #         - global, private : _snake_case_prefixed_underscore
   8 #         - local           : snake_case
   9 #     Functions:
  10 #         - global, public  : snake_case
  11
  12 BEGIN {
  13      FS = msg_fs ? msg_fs : "|"
  14     OFS = msg_fs ? msg_fs : "|"
  15     Kfs = key_fs ? key_fs : ":"
  16     GC_Interval = GC_Interval ? GC_Interval : 3600  # seconds
  17
  18     _total_to_diff["khatus_sensor_net_addr_io", "bytes_read"     ] = 1
  19     _total_to_diff["khatus_sensor_net_addr_io", "bytes_written"  ] = 1
  20     _total_to_diff["khatus_sensor_disk_io"    , "sectors_read"   ] = 1
  21     _total_to_diff["khatus_sensor_disk_io"    , "sectors_written"] = 1
  22
  23     # (x * y) / z = x * w
  24     #   ==> w = y / z
  25     # (x * bytes_per_sector) / bytes_per_mb = x * scaling_factor
  26     #   ==> scaling_factor = bytes_per_sector / bytes_per_mb
  27     _bytes_per_sector = 512
  28     _bytes_per_mb     = 1024 * 1024
  29     _scale["khatus_sensor_disk_io", "sectors_written"] = _bytes_per_sector / _bytes_per_mb
  30     _scale["khatus_sensor_disk_io", "sectors_read"   ] = _bytes_per_sector / _bytes_per_mb
  31     # (x / y) = x * z
  32     #   ==> z = 1 / y
  33     # x / bytes_per_mb = x * scaling_factor
  34     #   ==> scaling_factor = 1 / bytes_per_mb
  35     _scale["khatus_sensor_net_addr_io", "bytes_written"] = 1 / _bytes_per_mb
  36     _scale["khatus_sensor_net_addr_io", "bytes_read"   ] = 1 / _bytes_per_mb
  37 }
  38
  39 # -----------------------------------------------------------------------------
  40 # Input
  41 # -----------------------------------------------------------------------------
  42 $1 == "OK" {
  43     cache_update()
  44 }
  45
  46 $1 == "OK" && \
  47 $2 == "khatus_sensor_datetime" {
  48     # Code for make_status_bar definition is expected to be passed as an
  49     # additional source file, using  -f  flag.
  50     print_msg_ok("status_bar", make_status_bar())
  51 }
  52
  53 # -----------------------------------------------------------------------------
  54 # Cache
  55 # -----------------------------------------------------------------------------
  56
  57 function cache_update(    src, key, val, len_line, len_head, len_val, time) {
  58     src = $2
  59     key = $3
  60     # Not just using $4 for val - because an unstructured value (like name of a
  61     # song) might contain a character identical to FS
  62     len_line = length($0)
  63     len_head = length($1 FS $2 FS $3 FS)
  64     len_val  = len_line - len_head
  65     val = substr($0, len_head + 1, len_val)
  66     val = cache_maybe_total_to_diff(src, key, val)
  67     val = cache_maybe_scale(src, key, val)
  68     _cache[src, key] = val
  69     time = cache_get_time()
  70     _cache_mtime[src, key] = time
  71     if (time % GC_Interval == 0) {
  72         cache_gc()
  73     }
  74 }
  75
  76 function cache_get(result, src, key, ttl,    time, age, is_expired) {
  77     time = cache_get_time()
  78     _cache_atime[src, key] = time
  79     age = time - _cache_mtime[src, key]
  80     result["is_expired"] = ttl && age > ttl  # ttl = 0 => forever
  81     result["value"] = _cache[src, key]
  82 }
  83
  84 function cache_res_fmt_or_def(result, format, default) {
  85     return result["is_expired"] ? default : sprintf(format, result["value"])
  86 }
  87
  88 function cache_get_fmt_def(src, key, ttl, format, default,    result) {
  89     default = default ? default : "--"
  90     cache_get(result, src, key, ttl)
  91     return cache_res_fmt_or_def(result, format, default)
  92 }
  93
  94 function cache_get_time(    src, key, time) {
  95     src = "khatus_sensor_datetime"
  96     key = "epoch"
  97     time = _cache[src, key]
  98     _cache_atime[src, key] = time
  99     return time
 100 }
 101
 102 function cache_gc(    src_and_key, parts, src, key, unused_for) {
 103     for (src_and_key in _cache) {
 104         split(src_and_key, parts, SUBSEP)
 105         src = parts[1]
 106         key = parts[2]
 107         val = _cache[src, key]
 108         unused_for = cache_get_time() - _cache_atime[src, key]
 109         if (unused_for > GC_Interval) {
 110             print_msg_info(\
 111                 "cache_gc",
 112                 sprintf(\
 113                     "Deleting unused data SRC=%s KEY=%s VAL=%s",
 114                     src, key, val\
 115                 ) \
 116             )
 117             delete _cache[src, key]
 118         }
 119     }
 120 }
 121
 122 function cache_maybe_total_to_diff(src, key, val,    key_parts) {
 123     split(key, key_parts, Kfs)
 124     if (_total_to_diff[src, key_parts[1]]) {
 125         _prev[src, key] = _curr[src, key]
 126         _curr[src, key] = val
 127         return (_curr[src, key] - _prev[src, key])
 128     } else {
 129         return val
 130     }
 131 }
 132
 133 function cache_maybe_scale(src, key, val,    key_parts) {
 134     split(key, key_parts, Kfs)
 135     if ((src SUBSEP key_parts[1]) in _scale) {
 136         return val * _scale[src, key_parts[1]]
 137     } else {
 138         return val
 139     }
 140 }
 141
 142 # -----------------------------------------------------------------------------
 143 # Status bar
 144 # -----------------------------------------------------------------------------
 145
 146 function make_status_energy(    state, charge, direction_of_change) {
 147     cache_get(state , "khatus_sensor_energy", "battery_state"     , 0)
 148     cache_get(charge, "khatus_sensor_energy", "battery_percentage", 0)
 149
 150     if (state["value"] == "discharging") {
 151         direction_of_change = "<"
 152     } else if (state["value"] == "charging") {
 153         direction_of_change = ">"
 154     } else {
 155         direction_of_change = "="
 156     }
 157
 158     return sprintf("E%s%d%%", direction_of_change, charge["value"])
 159 }
 160
 161 function make_status_mem(    total, used, percent, status) {
 162     cache_get(total, "khatus_sensor_memory", "total", 5)
 163     cache_get(used , "khatus_sensor_memory", "used" , 5)
 164     # Checking total["value"] to avoid division by zero when data is missing
 165     if (!total["is_expired"] && \
 166         !used["is_expired"] && \
 167         total["value"] \
 168         ) {
 169         percent = round((used["value"] / total["value"]) * 100)
 170         status = sprintf("%d%%", percent)
 171     } else {
 172         status = "__"
 173     }
 174     return sprintf("M=%s", status)
 175 }
 176
 177 function make_status_procs() {
 178     src = "khatus_sensor_procs"
 179     all = cache_get_fmt_def(src, "total_procs"            , 15, "%d")
 180     r   = cache_get_fmt_def(src, "total_per_state" Kfs "R", 15, "%d", "0")
 181     d   = cache_get_fmt_def(src, "total_per_state" Kfs "D", 15, "%d", "0")
 182     t   = cache_get_fmt_def(src, "total_per_state" Kfs "T", 15, "%d", "0")
 183     i   = cache_get_fmt_def(src, "total_per_state" Kfs "I", 15, "%d", "0")
 184     z   = cache_get_fmt_def(src, "total_per_state" Kfs "Z", 15, "%d", "0")
 185     return sprintf("P=[%s %sr %sd %st %si %sz]", all, r, d, t, i, z)
 186 }
 187
 188 function make_status_cpu(    l, t, f) {
 189     l_src = "khatus_sensor_loadavg"
 190     t_src = "khatus_sensor_temperature"
 191     f_src = "khatus_sensor_fan"
 192     l = cache_get_fmt_def(l_src, "load_avg_1min", 5, "%4.2f")
 193     t = cache_get_fmt_def(t_src, "temp_c"       , 5, "%d"   )
 194     f = cache_get_fmt_def(f_src, "speed"        , 5, "%4d"  )
 195     return sprintf("C=[%s %s°C %srpm]", l, t, f)
 196 }
 197
 198 function make_status_disk(    u, w, r, src_u, src_io) {
 199     src_u  = "khatus_sensor_disk_space"
 200     src_io = "khatus_sensor_disk_io"
 201     u = cache_get_fmt_def(src_u , "disk_usage_percentage", 10, "%s")
 202     w = cache_get_fmt_def(src_io, "sectors_written"      ,  5, "%0.3f")
 203     r = cache_get_fmt_def(src_io, "sectors_read"         ,  5, "%0.3f")
 204     return sprintf("D=[%s%% %s▲ %s▼]", u, w, r)
 205 }
 206
 207 function make_status_net(    \
 208     number_of_net_interfaces_to_show, \
 209     net_interfaces_to_show, \
 210     io, \
 211     wi, \
 212     i, \
 213     interface, \
 214     label, \
 215     wifi, \
 216     addr, \
 217     w, \
 218     r, \
 219     io_stat, \
 220     out, \
 221     sep \
 222 ) {
 223     number_of_net_interfaces_to_show = \
 224         split(Opt_Net_Interfaces_To_Show, net_interfaces_to_show, ",")
 225     io = "khatus_sensor_net_addr_io"
 226     wi = "khatus_sensor_net_wifi_status"
 227     out = ""
 228     sep = ""
 229     for (i = number_of_net_interfaces_to_show; i > 0; i--) {
 230         interface = net_interfaces_to_show[i]
 231         label = substr(interface, 1, 1)
 232         if (interface ~ "^w") {
 233             wifi = cache_get_fmt_def(wi, "status" Kfs interface, 10, "%s")
 234             label = label ":" wifi
 235         }
 236         addr = cache_get_fmt_def(io, "addr"          Kfs interface, 5, "%s", "")
 237         w    = cache_get_fmt_def(io, "bytes_written" Kfs interface, 5, "%0.3f")
 238         r    = cache_get_fmt_def(io, "bytes_read"    Kfs interface, 5, "%0.3f")
 239         io_stat = addr ? sprintf("%s▲ %s▼", w, r) : "--"
 240         out = out sep label ":" io_stat
 241         sep = " "
 242     }
 243     return sprintf("N[%s]", out)
 244 }
 245
 246 function make_status_bluetooth(    src, key) {
 247     src = "khatus_sensor_bluetooth_power"
 248     key = "power_status"
 249     return sprintf("B=%s", cache_get_fmt_def(src, key, 10, "%s"))
 250 }
 251
 252 function make_status_screen_brightness(    src, key) {
 253     src = "khatus_sensor_screen_brightness"
 254     key = "percentage"
 255     return sprintf("*%s%%", cache_get_fmt_def(src, key, 5, "%d"))
 256 }
 257
 258 function make_status_volume(    sink, mu, vl, vr, show) {
 259     sink = Opt_Pulseaudio_Sink
 260     cache_get(mu, "khatus_sensor_volume", "mute"      Kfs sink, 5)
 261     cache_get(vl, "khatus_sensor_volume", "vol_left"  Kfs sink, 5)
 262     cache_get(vr, "khatus_sensor_volume", "vol_right" Kfs sink, 5)
 263     show = "--"
 264     if (!mu["is_expired"] && !vl["is_expired"] && !vr["is_expired"]) {
 265              if (mu["value"] == "yes") {show = "X"}
 266         else if (mu["value"] == "no")  {show = vl["value"] " " vr["value"]}
 267         else {
 268             print_msg_error(\
 269                 "make_status_volume", \
 270                 "Unexpected value for 'mute' field: " mu["value"] \
 271             )
 272         }
 273     }
 274     return sprintf("(%s)", show)
 275 }
 276
 277 function make_status_mpd(    state, status) {
 278     cache_get(state, "khatus_sensor_mpd", "state", 5)
 279     if (!state["is_expired"] && state["value"]) {
 280         if (state["value"] == "play") {
 281             status = make_status_mpd_state_known("▶")
 282         } else if (state["value"] == "pause") {
 283             status = make_status_mpd_state_known("❚❚")
 284         } else if (state["value"] == "stop") {
 285             status = make_status_mpd_state_known("⬛")
 286         } else {
 287             print_msg_error(\
 288                 "make_status_mpd", \
 289                 "Unexpected value for 'state' field: " state["value"] \
 290             )
 291             status = "--"
 292         }
 293     } else {
 294         status = "--"
 295     }
 296
 297     return sprintf("[%s]", status)
 298 }
 299
 300 function make_status_mpd_state_known(symbol,    s, song, time, percentage) {
 301     s = "khatus_sensor_mpd"
 302     song    = cache_get_fmt_def(s, "song"                   , 5, "%s", "?")
 303     time    = cache_get_fmt_def(s, "play_time_minimal_units", 5, "%s", "?")
 304     percent = cache_get_fmt_def(s, "play_time_percentage"   , 5, "%s", "?")
 305     song    = substr(song, 1, Opt_Mpd_Song_Max_Chars)
 306     return sprintf("%s %s %s %s", symbol, time, percent, song)
 307 }
 308
 309 function make_status_weather(    src, hour, t_f) {
 310     src = "khatus_sensor_weather"
 311     hour = 60 * 60
 312     t_f = cache_get_fmt_def(src, "temperature_f", 3 * hour, "%d")
 313     return sprintf("%s°F", t_f)
 314 }
 315
 316 function make_status_datetime(    dt) {
 317     return cache_get_fmt_def("khatus_sensor_datetime", "datetime", 5, "%s")
 318 }
 319
 320 # -----------------------------------------------------------------------------
 321 # Output
 322 # -----------------------------------------------------------------------------
 323
 324 function print_msg_ok(key, val) {
 325     print_msg("OK", key, val, "/dev/stdout")
 326 }
 327
 328 function print_msg_info(location, msg) {
 329     print_msg("INFO", location, msg, "/dev/stderr")
 330 }
 331
 332 function print_msg_error(location, msg) {
 333     print_msg("ERROR", location, msg, "/dev/stderr")
 334 }
 335
 336 function print_msg(status, key, val, channel) {
 337     print(status, "khatus_bar", key, val) > channel
 338 }
 339
 340 # -----------------------------------------------------------------------------
 341 # Numbers
 342 # -----------------------------------------------------------------------------
 343
 344 function round(n) {
 345     return int(n + 0.5)
 346 }