bin/khatus_bar

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