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