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