[khatus.git] / bin / khatus_controller

#! /usr/bin/awk -f


/^in:ENERGY/\
{
    split_msg_parts()
    sub("%$", "", $2)
    db["energy_state"]      = $1
    db["energy_percentage"] = ensure_numeric($2)
    alert_check_energy()
}

/^in:MEMORY/\
{
    split_msg_parts()
    db["memory_total"] = $1
    db["memory_used"]  = $2
}

/^in:FAN +status:/\
{
    split_msg_parts()
    db["fan_status"] = $2
}

/^in:FAN +speed:/\
{
    split_msg_parts()
    db["fan_speed"] = $2
}

/^in:FAN +level:/\
{
    split_msg_parts()
    db["fan_level"] = $2
}

/^in:TEMPERATURE/\
{
    split_msg_parts()
    db["temperature"] = $1
}

/^in:LOAD_AVG/\
{
    split_msg_parts()
    set_load_avg()
}

/^in:DISK_IO/\
{
    split_msg_parts()
    set_disk_io()
}

/^in:DISK_SPACE/\
{
    split_msg_parts()
    db["disk_space_used"] = msg_body
}

/^in:NET_ADDR_IO/\
{
    split_msg_parts()
    set_net_addr_io()
}

/^in:NET_WIFI_STATUS/\
{
    split_msg_parts()
    db["net_wifi_status"] = msg_body
}

/^in:BLUETOOTH_POWER/\
{
    split_msg_parts()
    db["bluetooth_power"] = msg_body
}

/^in:SCREEN_BRIGHTNESS/\
{
    split_msg_parts()
    set_screen_brightness()
}

/^in:VOLUME/\
{
    split_msg_parts()
    db["volume"] = msg_body
}

/^in:MPD_STATE/\
{
    split_msg_parts()
    db["mpd_state"]             = $1
    db["mpd_curr_song_time"]    = $2
    db["mpd_curr_song_percent"] = $3
}

/^in:MPD_SONG/\
{
    split_msg_parts()
    db["mpd_curr_song_name"] = msg_body
}

/^in:WEATHER/\
{
    split_msg_parts()
    db["weather_temperature"] = msg_body
}

/^in:DATE_TIME/\
{
    split_msg_parts()
    db["datetime"] = msg_body
    output_msg_status_bar(make_status_bar())
}

# TODO: Generalize alert spec lang
#       - trigger threshold
#       - above/bellow/equal to threshold value
#       - priority
#       - snooze time (if already alerted, when to re-alert?)
#       - text: subject/body
function alert_check_energy(    from, dbg, state, remaining, subj, body) {
    from = "alert_check_energy"

    state     = db["energy_state"]
    remaining = db["energy_percentage"]

    dbg["state"] = state
    dbg["remaining"] = remaining
    debug(from, dbg)

    if (state == "discharging") {
        if (remaining < 5) {
            subj = "Energy_CRITICALLY_Low"
            body = sprintf("%d%% CHARGE NOW!!! GO GO GO!!!", remaining)
            alert_trigger_hi(from, subj, body)
        } else if (remaining < 10) {
            subj = "Energy_Very_Low"
            body = sprintf("%d%% Plug it in ASAP.", remaining)
            alert_trigger_hi(from, subj, body)
        } else if (remaining < 15) {
            subj = "Energy_Low"
            body = sprintf("%d%% Get the charger.", remaining)
            alert_trigger_hi(from, subj, body)
        } else if (remaining < 20) {
            subj = "Energy_Low"
            body = sprintf("%d%% Get the charger.", remaining)
            alert_trigger_med(from, subj, body)
        } else if (remaining < 50) {
            if (!state__alerts__energy__notified_bellow_half) {
                state__alerts__energy__notified_bellow_half = 1
                subj = "Energy_Bellow_Half"
                body = sprintf("%d%% Where is the charger?", remaining)
                alert_trigger_med(from, subj, body)
            }
        }
    } else {
        # TODO: Reconsider the competing global-state organizing-conventions
        state__alerts__energy__notified_bellow_half = 0
    }
}

function alert_trigger_low(from, subject, body) {
    alert_trigger("low", from, subject, body)
}

function alert_trigger_med(from, subject, body) {
    alert_trigger("med", from, subject, body)
}

function alert_trigger_hi(from, subject, body) {
    alert_trigger("hi", from, subject, body)
}

function alert_trigger(priority, from, subject, body,    msg) {
    # priority : "low" | "med" | "hi"
    # subject  : no spaces
    # body     : anything
    msg = sprintf("khatus_%s %s %s %s", from, priority, subject, body)
    output_msg_alert(msg)
}

function output_msg_alert(msg) {
    # TODO: Should alerts go into a dedicated channel?
    output_msg("ALERT", msg, "/dev/stdout")
}

function output_msg_status_bar(msg) {
    output_msg("STATUS_BAR", msg, "/dev/stdout")
}

function output_msg(type, content, channel) {
    print(type, content) > channel
}

function set_load_avg(    sched) {
    split($4, sched, "/")
    db["load_avg_1min"]             = $1
    db["load_avg_5min"]             = $2
    db["load_avg_15min"]            = $3
    db["kern_sched_queue_runnable"] = sched[1]
    db["kern_sched_queue_total"]    = sched[2]
    db["kern_sched_latest_pid"]     = $5
}

function set_disk_io(    curr_w, curr_r, prev_w, prev_r) {
    curr_w = $1
    curr_r = $2
    prev_w = db["disk_io_curr_w"]
    prev_r = db["disk_io_curr_r"]
    db["disk_io_curr_w"] = curr_w
    db["disk_io_curr_r"] = curr_r
    db["disk_io_diff_w"] = curr_w - prev_w
    db["disk_io_diff_r"] = curr_r - prev_r
}

function set_net_addr_io(    \
    interface, address, io_curr_w, io_curr_r, io_prev_w, io_prev_r\
) {
    interface = $1
    address   = $2
    io_curr_w = $3
    io_curr_r = $4
    if (interface) {
        if (address && io_curr_w && io_curr_r) {
            # recalculate
            io_prev_w = net_io_curr_w[interface]
            io_prev_r = net_io_curr_r[interface]

            net_addr[interface]      = address
            net_io_curr_w[interface] = io_curr_w
            net_io_curr_r[interface] = io_curr_r
            net_io_diff_w[interface] = io_curr_w - io_prev_w
            net_io_diff_r[interface] = io_curr_r - io_prev_r
        } else {
            # clear
            net_addr[interface]      = ""
            net_io_curr_w[interface] = 0
            net_io_curr_r[interface] = 0
            net_io_diff_w[interface] = 0
            net_io_diff_r[interface] = 0
        }
    }
}

function set_screen_brightness(    max, cur) {
    max = $1
    cur = $2
    db["screen_brightness"] = (cur / max) * 100
}

function split_msg_parts(    dbg) {
    msg_head = $1
    sub("^" msg_head " +", "")
    msg_body = $0
    dbg["msg_head"] = msg_head
    dbg["msg_body"] = msg_body
    debug("split_msg_parts", dbg)
}

function make_status_bar(    position, bar, sep, i, j) {
    position[++i] = make_status_energy()
    position[++i] = make_status_mem()
    position[++i] = make_status_cpu()
    position[++i] = make_status_disk()
    position[++i] = make_status_net()
    position[++i] = sprintf("B=%s", db["bluetooth_power"])
    position[++i] = sprintf("*%d%%", db["screen_brightness"])
    position[++i] = sprintf("(%s)", db["volume"])
    position[++i] = make_status_mpd()
    position[++i] = db["weather_temperature"]
    position[++i] = db["datetime"]
    bar = ""
    sep = ""
    for (j = 1; j <= i; j++) {
        bar = bar sep position[j]
        sep = " "
    }
    return bar
}

function make_status_energy(    state, direction_of_change) {
    state = db["energy_state"]
    if (state == "discharging") {
        direction_of_change = "<"
    } else if (state == "charging") {
        direction_of_change = ">"
    } else {
        direction_of_change = "="
    };
    return sprintf("E%s%d%%", direction_of_change, db["energy_percentage"])
}

function make_status_mem(    total, used, percent, status) {
    total = db["memory_total"]
    used  = db["memory_used"]
    # To avoid division by zero when data is missing
    if (total && used) {
        percent = round((used / total) * 100)
        status = sprintf("%d%%", percent)
    } else {
        status = "__"
    }
    return sprintf("M=%s", status)
}

function make_status_cpu(    load, temp, fan) {
    load = db["load_avg_1min"]
    temp = db["temperature"] / 1000
    fan  = db["fan_speed"]
    return sprintf("C=[%4.2f %d°C %4drpm]", load, temp, fan)
}

function make_status_disk(    bytes_per_sector, bytes_per_mb, w, r) {
    bytes_per_sector = 512
    bytes_per_mb     = 1024 * 1024
    w = (db["disk_io_diff_w"] * bytes_per_sector) / bytes_per_mb
    r = (db["disk_io_diff_r"] * bytes_per_sector) / bytes_per_mb
    return \
        sprintf("D=[%s %0.3f▲ %0.3f▼]", db["disk_space_used"], w, r)
}

function make_status_net(    \
    out,
    number_of_interfaces_to_show,
    n,
    array_of_prefixes_of_interfaces_to_show,
    prefix,
    interface,
    label,
    count_printed,
    sep,
    io_stat,
    dw, dr,
    bytes_per_unit\
) {
    out = ""
    number_of_interfaces_to_show = \
        split(\
            opt_prefixes_of_net_interfaces_to_show,\
            array_of_prefixes_of_interfaces_to_show,\
            ","\
        )
    for (n = 1; n <= number_of_interfaces_to_show; n++) {
        prefix = array_of_prefixes_of_interfaces_to_show[n]
        for (interface in net_addr) {
            if (interface ~ ("^" prefix)) {
                label = substr(interface, 1, 1)
                if (net_addr[interface]) {
                    bytes_per_mb = 1024 * 1024  # TODO: option
                    dw = net_io_diff_w[interface] / bytes_per_mb
                    dr = net_io_diff_r[interface] / bytes_per_mb
                    io_stat = sprintf("%0.3f▲ %0.3f▼", dw, dr)
                } else {
                    io_stat = "--"
                }
                if (interface ~ "^w") {
                    label = label ":" db["net_wifi_status"]
                }
                if (++count_printed > 1) {
                    sep = "  "
                } else {
                    sep = ""
                }
                out = out sep label ":" io_stat
            }
        }
    }
    return sprintf("N[%s]", out)
}

function make_status_mpd(    state, status) {
    state = db["mpd_state"]

    if (state == "play") {
        status = make_status_mpd_state_known("▶")
    } else if (state == "pause") {
        status = make_status_mpd_state_known("❚❚")
    } else if (state == "stop") {
        status = make_status_mpd_state_known("⬛")
    } else {
        status = make_status_mpd_state_unknown("--")
    }

    return sprintf("[%s]", status)
}

function make_status_mpd_state_known(symbol) {
    return sprintf(\
        "%s %s %s %s",
        symbol,
        db["mpd_curr_song_time"],
        db["mpd_curr_song_percent"],
        substr(db["mpd_curr_song_name"], 1, opt_mpd_song_max_chars)\
    )
}

function make_status_mpd_state_unknown(symbol) {
    return sprintf("%s", symbol)
}

function round(n) {
    return int(n + 0.5)
}

function debug(location, values,    sep, vals, key, msg) {
    if (opt_debug) {
        sep = ""
        vals = ""
        for (key in values) {
            vals = sprintf("%s%s%s: %s", vals, sep, key, values[key])
            sep = ", "
        }
        msg = location " ==> " vals "."
        output_msg("DEBUG", msg, "/dev/stderr")
    }
}

function ensure_numeric(n) {
    return n + 0
}
#-------------------------------
# Why do we need ensure_numeric?
#-------------------------------
# awk appears to be guessing the type of an inputted scalar based on usage, so
# if we read-in a number, but did not use it in any numeric operations, but did
# use as a string (even in just a format string!) - it will be treated as a
# string and can lead to REALLY SURPRISING behavior in conditional statements,
# where smaller number may compare as greater than the bigger ones, such as.
#
# Demo:
#
# $ awk 'BEGIN {x = "75"; y = "100"; sprintf("x: %d, y: %d\n", x, y); if (x > y) {print "75 > 100"} else if (x < y) {print "75 < 100"}}'
# 75 < 100
# $ awk 'BEGIN {x = "75"; y = "100"; sprintf("x: %s, y: %d\n", x, y); if (x > y) {print "75 > 100"} else if (x < y) {print "75 < 100"}}'
# 75 > 100

# However, once used as a number, seems to stay that way even after being
# used as string:
#
# $ awk 'BEGIN {x = "75"; y = "100"; x + y; sprintf("x: %s, y: %d\n", x, y); if (x > y) {print "75 > 100"} else if (x < y) {print "75 < 100"}}'
# 75 < 100
# 
# $ awk 'BEGIN {x = "75"; y = "100"; x + y; sprintf("x: %s, y: %d\n", x, y); z = x y; if (x > y) {print "75 > 100"} else if (x < y) {print "75 < 100"}}'
# 75 < 100
# 
# $ awk 'BEGIN {x = "75"; y = "100"; x + y; z = x y; if (x > y) {print "75 > 100"} else if (x < y) {print "75 < 100"}}'
# 75 < 100
# $ awk 'BEGIN {x = "75"; y = "100"; z = x y; if (x > y) {print "75 > 100"} else if (x < y) {print "75 < 100"}}'
# 75 > 100
Commit	Line	Data
f37162a4 SK	1	#! /usr/bin/awk -f
f37162a4 SK	2
e16fe0ea	3
f37162a4 SK	4	/^in:ENERGY/\
	5	{
	6	split_msg_parts()
cae87802	7	sub("%$", "", $2)
f37162a4	8	db["energy_state"] = $1
e16fe0ea SK	9	db["energy_percentage"] = ensure_numeric($2)
e16fe0ea SK	10	alert_check_energy()
f37162a4 SK	11	}
	12
	13	/^in:MEMORY/\
	14	{
	15	split_msg_parts()
	16	db["memory_total"] = $1
	17	db["memory_used"] = $2
	18	}
	19
	20	/^in:FAN +status:/\
	21	{
	22	split_msg_parts()
	23	db["fan_status"] = $2
	24	}
	25
	26	/^in:FAN +speed:/\
	27	{
	28	split_msg_parts()
	29	db["fan_speed"] = $2
	30	}
	31
	32	/^in:FAN +level:/\
	33	{
	34	split_msg_parts()
	35	db["fan_level"] = $2
	36	}
	37
	38	/^in:TEMPERATURE/\
	39	{
	40	split_msg_parts()
	41	db["temperature"] = $1
	42	}
	43
	44	/^in:LOAD_AVG/\
	45	{
	46	split_msg_parts()
	47	set_load_avg()
	48	}
	49
	50	/^in:DISK_IO/\
	51	{
	52	split_msg_parts()
	53	set_disk_io()
	54	}
	55
	56	/^in:DISK_SPACE/\
	57	{
	58	split_msg_parts()
	59	db["disk_space_used"] = msg_body
	60	}
	61
	62	/^in:NET_ADDR_IO/\
	63	{
	64	split_msg_parts()
	65	set_net_addr_io()
	66	}
	67
	68	/^in:NET_WIFI_STATUS/\
	69	{
	70	split_msg_parts()
	71	db["net_wifi_status"] = msg_body
	72	}
	73
	74	/^in:BLUETOOTH_POWER/\
75	{
76	split_msg_parts()
77	db["bluetooth_power"] = msg_body
78	}
79
80	/^in:SCREEN_BRIGHTNESS/\
81	{
82	split_msg_parts()
83	set_screen_brightness()
84	}
85
86	/^in:VOLUME/\
87	{
88	split_msg_parts()
89	db["volume"] = msg_body
90	}
91
92	/^in:MPD_STATE/\
93	{
94	split_msg_parts()
95	db["mpd_state"] = $1
96	db["mpd_curr_song_time"] = $2
97	db["mpd_curr_song_percent"] = $3
98	}
99
100	/^in:MPD_SONG/\
101	{
102	split_msg_parts()
103	db["mpd_curr_song_name"] = msg_body
104	}
105
106	/^in:WEATHER/\
107	{
108	split_msg_parts()
109	db["weather_temperature"] = msg_body
110	}
111
112	/^in:DATE_TIME/\
113	{
114	split_msg_parts()
115	db["datetime"] = msg_body
cae87802 SK	116	output_msg_status_bar(make_status_bar())
	117	}
	118
cae87802 SK	119	# TODO: Generalize alert spec lang
	120	# - trigger threshold
	121	# - above/bellow/equal to threshold value
	122	# - priority
	123	# - snooze time (if already alerted, when to re-alert?)
	124	# - text: subject/body
d4c26c51 SK	125	function alert_check_energy( from, dbg, state, remaining, subj, body) {
	126	from = "alert_check_energy"
	127
cae87802 SK	128	state = db["energy_state"]
cae87802 SK	129	remaining = db["energy_percentage"]
e16fe0ea SK	130
	131	dbg["state"] = state
	132	dbg["remaining"] = remaining
d4c26c51	133	debug(from, dbg)
e16fe0ea	134
cae87802 SK	135	if (state == "discharging") {
	136	if (remaining < 5) {
	137	subj = "Energy_CRITICALLY_Low"
	138	body = sprintf("%d%% CHARGE NOW!!! GO GO GO!!!", remaining)
d4c26c51	139	alert_trigger_hi(from, subj, body)
cae87802 SK	140	} else if (remaining < 10) {
	141	subj = "Energy_Very_Low"
	142	body = sprintf("%d%% Plug it in ASAP.", remaining)
d4c26c51	143	alert_trigger_hi(from, subj, body)
cae87802 SK	144	} else if (remaining < 15) {
	145	subj = "Energy_Low"
	146	body = sprintf("%d%% Get the charger.", remaining)
d4c26c51	147	alert_trigger_hi(from, subj, body)
361523eb SK	148	} else if (remaining < 20) {
	149	subj = "Energy_Low"
	150	body = sprintf("%d%% Get the charger.", remaining)
	151	alert_trigger_med(from, subj, body)
cae87802 SK	152	} else if (remaining < 50) {
	153	if (!state__alerts__energy__notified_bellow_half) {
	154	state__alerts__energy__notified_bellow_half = 1
	155	subj = "Energy_Bellow_Half"
	156	body = sprintf("%d%% Where is the charger?", remaining)
d4c26c51	157	alert_trigger_med(from, subj, body)
cae87802 SK	158	}
	159	}
	160	} else {
	161	# TODO: Reconsider the competing global-state organizing-conventions
	162	state__alerts__energy__notified_bellow_half = 0
	163	}
	164	}
	165
d4c26c51 SK	166	function alert_trigger_low(from, subject, body) {
d4c26c51 SK	167	alert_trigger("low", from, subject, body)
cae87802 SK	168	}
cae87802 SK	169
d4c26c51 SK	170	function alert_trigger_med(from, subject, body) {
d4c26c51 SK	171	alert_trigger("med", from, subject, body)
cae87802 SK	172	}
cae87802 SK	173
d4c26c51 SK	174	function alert_trigger_hi(from, subject, body) {
d4c26c51 SK	175	alert_trigger("hi", from, subject, body)
cae87802 SK	176	}
cae87802 SK	177
d4c26c51	178	function alert_trigger(priority, from, subject, body, msg) {
cae87802 SK	179	# priority : "low" \| "med" \| "hi"
	180	# subject : no spaces
	181	# body : anything
d4c26c51	182	msg = sprintf("khatus_%s %s %s %s", from, priority, subject, body)
cae87802 SK	183	output_msg_alert(msg)
	184	}
	185
	186	function output_msg_alert(msg) {
	187	# TODO: Should alerts go into a dedicated channel?
	188	output_msg("ALERT", msg, "/dev/stdout")
	189	}
	190
	191	function output_msg_status_bar(msg) {
	192	output_msg("STATUS_BAR", msg, "/dev/stdout")
	193	}
	194
	195	function output_msg(type, content, channel) {
	196	print(type, content) > channel
f37162a4 SK	197	}
	198
	199	function set_load_avg( sched) {
	200	split($4, sched, "/")
	201	db["load_avg_1min"] = $1
	202	db["load_avg_5min"] = $2
	203	db["load_avg_15min"] = $3
	204	db["kern_sched_queue_runnable"] = sched[1]
	205	db["kern_sched_queue_total"] = sched[2]
	206	db["kern_sched_latest_pid"] = $5
	207	}
	208
	209	function set_disk_io( curr_w, curr_r, prev_w, prev_r) {
	210	curr_w = $1
	211	curr_r = $2
	212	prev_w = db["disk_io_curr_w"]
	213	prev_r = db["disk_io_curr_r"]
	214	db["disk_io_curr_w"] = curr_w
	215	db["disk_io_curr_r"] = curr_r
	216	db["disk_io_diff_w"] = curr_w - prev_w
	217	db["disk_io_diff_r"] = curr_r - prev_r
	218	}
	219
	220	function set_net_addr_io( \
	221	interface, address, io_curr_w, io_curr_r, io_prev_w, io_prev_r\
	222	) {
	223	interface = $1
	224	address = $2
	225	io_curr_w = $3
	226	io_curr_r = $4
	227	if (interface) {
	228	if (address && io_curr_w && io_curr_r) {
	229	# recalculate
	230	io_prev_w = net_io_curr_w[interface]
	231	io_prev_r = net_io_curr_r[interface]
	232
	233	net_addr[interface] = address
	234	net_io_curr_w[interface] = io_curr_w
	235	net_io_curr_r[interface] = io_curr_r
	236	net_io_diff_w[interface] = io_curr_w - io_prev_w
	237	net_io_diff_r[interface] = io_curr_r - io_prev_r
	238	} else {
	239	# clear
	240	net_addr[interface] = ""
	241	net_io_curr_w[interface] = 0
	242	net_io_curr_r[interface] = 0
	243	net_io_diff_w[interface] = 0
	244	net_io_diff_r[interface] = 0
	245	}
	246	}
	247	}
	248
	249	function set_screen_brightness( max, cur) {
	250	max = $1
	251	cur = $2
	252	db["screen_brightness"] = (cur / max) * 100
	253	}
	254
e16fe0ea	255	function split_msg_parts( dbg) {
f37162a4 SK	256	msg_head = $1
	257	sub("^" msg_head " +", "")
	258	msg_body = $0
e16fe0ea SK	259	dbg["msg_head"] = msg_head
	260	dbg["msg_body"] = msg_body
	261	debug("split_msg_parts", dbg)
f37162a4 SK	262	}
f37162a4 SK	263
cae87802	264	function make_status_bar( position, bar, sep, i, j) {
f37162a4 SK	265	position[++i] = make_status_energy()
	266	position[++i] = make_status_mem()
	267	position[++i] = make_status_cpu()
	268	position[++i] = make_status_disk()
	269	position[++i] = make_status_net()
	270	position[++i] = sprintf("B=%s", db["bluetooth_power"])
	271	position[++i] = sprintf("*%d%%", db["screen_brightness"])
	272	position[++i] = sprintf("(%s)", db["volume"])
	273	position[++i] = make_status_mpd()
	274	position[++i] = db["weather_temperature"]
	275	position[++i] = db["datetime"]
	276	bar = ""
	277	sep = ""
	278	for (j = 1; j <= i; j++) {
	279	bar = bar sep position[j]
	280	sep = " "
	281	}
	282	return bar
	283	}
	284
	285	function make_status_energy( state, direction_of_change) {
	286	state = db["energy_state"]
	287	if (state == "discharging") {
	288	direction_of_change = "<"
	289	} else if (state == "charging") {
	290	direction_of_change = ">"
	291	} else {
	292	direction_of_change = "="
	293	};
e16fe0ea	294	return sprintf("E%s%d%%", direction_of_change, db["energy_percentage"])
f37162a4 SK	295	}
	296
	297	function make_status_mem( total, used, percent, status) {
	298	total = db["memory_total"]
	299	used = db["memory_used"]
	300	# To avoid division by zero when data is missing
	301	if (total && used) {
	302	percent = round((used / total) * 100)
	303	status = sprintf("%d%%", percent)
	304	} else {
	305	status = "__"
	306	}
	307	return sprintf("M=%s", status)
	308	}
	309
	310	function make_status_cpu( load, temp, fan) {
	311	load = db["load_avg_1min"]
	312	temp = db["temperature"] / 1000
	313	fan = db["fan_speed"]
	314	return sprintf("C=[%4.2f %d°C %4drpm]", load, temp, fan)
	315	}
	316
	317	function make_status_disk( bytes_per_sector, bytes_per_mb, w, r) {
	318	bytes_per_sector = 512
	319	bytes_per_mb = 1024 * 1024
	320	w = (db["disk_io_diff_w"] * bytes_per_sector) / bytes_per_mb
	321	r = (db["disk_io_diff_r"] * bytes_per_sector) / bytes_per_mb
	322	return \
	323	sprintf("D=[%s %0.3f▲ %0.3f▼]", db["disk_space_used"], w, r)
	324	}
	325
	326	function make_status_net( \
	327	out,
	328	number_of_interfaces_to_show,
	329	n,
	330	array_of_prefixes_of_interfaces_to_show,
	331	prefix,
	332	interface,
	333	label,
	334	count_printed,
	335	sep,
	336	io_stat,
	337	dw, dr,
	338	bytes_per_unit\
	339	) {
	340	out = ""
	341	number_of_interfaces_to_show = \
	342	split(\
	343	opt_prefixes_of_net_interfaces_to_show,\
	344	array_of_prefixes_of_interfaces_to_show,\
	345	","\
	346	)
	347	for (n = 1; n <= number_of_interfaces_to_show; n++) {
	348	prefix = array_of_prefixes_of_interfaces_to_show[n]
	349	for (interface in net_addr) {
	350	if (interface ~ ("^" prefix)) {
	351	label = substr(interface, 1, 1)
	352	if (net_addr[interface]) {
	353	bytes_per_mb = 1024 * 1024 # TODO: option
	354	dw = net_io_diff_w[interface] / bytes_per_mb
	355	dr = net_io_diff_r[interface] / bytes_per_mb
	356	io_stat = sprintf("%0.3f▲ %0.3f▼", dw, dr)
	357	} else {
	358	io_stat = "--"
359	}
360	if (interface ~ "^w") {
361	label = label ":" db["net_wifi_status"]
362	}
363	if (++count_printed > 1) {
364	sep = " "
365	} else {
366	sep = ""
367	}
368	out = out sep label ":" io_stat
369	}
370	}
371	}
372	return sprintf("N[%s]", out)
373	}
374
375	function make_status_mpd( state, status) {
376	state = db["mpd_state"]
377
378	if (state == "play") {
379	status = make_status_mpd_state_known("▶")
380	} else if (state == "pause") {
381	status = make_status_mpd_state_known("❚❚")
382	} else if (state == "stop") {
383	status = make_status_mpd_state_known("⬛")
384	} else {
385	status = make_status_mpd_state_unknown("--")
386	}
387
388	return sprintf("[%s]", status)
389	}
390
391	function make_status_mpd_state_known(symbol) {
392	return sprintf(\
393	"%s %s %s %s",
394	symbol,
395	db["mpd_curr_song_time"],
396	db["mpd_curr_song_percent"],
397	substr(db["mpd_curr_song_name"], 1, opt_mpd_song_max_chars)\
398	)
399	}
400
401	function make_status_mpd_state_unknown(symbol) {
402	return sprintf("%s", symbol)
403	}
404
405	function round(n) {
406	return int(n + 0.5)
407	}
408
e16fe0ea	409	function debug(location, values, sep, vals, key, msg) {
f37162a4	410	if (opt_debug) {
e16fe0ea SK	411	sep = ""
	412	vals = ""
	413	for (key in values) {
	414	vals = sprintf("%s%s%s: %s", vals, sep, key, values[key])
	415	sep = ", "
	416	}
	417	msg = location " ==> " vals "."
	418	output_msg("DEBUG", msg, "/dev/stderr")
f37162a4 SK	419	}
f37162a4 SK	420	}
e16fe0ea SK	421
	422	function ensure_numeric(n) {
	423	return n + 0
	424	}
	425	#-------------------------------
	426	# Why do we need ensure_numeric?
	427	#-------------------------------
	428	# awk appears to be guessing the type of an inputted scalar based on usage, so
	429	# if we read-in a number, but did not use it in any numeric operations, but did
	430	# use as a string (even in just a format string!) - it will be treated as a
	431	# string and can lead to REALLY SURPRISING behavior in conditional statements,
	432	# where smaller number may compare as greater than the bigger ones, such as.
	433	#
	434	# Demo:
	435	#
	436	# $ awk 'BEGIN {x = "75"; y = "100"; sprintf("x: %d, y: %d\n", x, y); if (x > y) {print "75 > 100"} else if (x < y) {print "75 < 100"}}'
	437	# 75 < 100
	438	# $ awk 'BEGIN {x = "75"; y = "100"; sprintf("x: %s, y: %d\n", x, y); if (x > y) {print "75 > 100"} else if (x < y) {print "75 < 100"}}'
	439	# 75 > 100
	440
	441	# However, once used as a number, seems to stay that way even after being
	442	# used as string:
	443	#
	444	# $ awk 'BEGIN {x = "75"; y = "100"; x + y; sprintf("x: %s, y: %d\n", x, y); if (x > y) {print "75 > 100"} else if (x < y) {print "75 < 100"}}'
	445	# 75 < 100
	446	#
	447	# $ awk 'BEGIN {x = "75"; y = "100"; x + y; sprintf("x: %s, y: %d\n", x, y); z = x y; if (x > y) {print "75 > 100"} else if (x < y) {print "75 < 100"}}'
	448	# 75 < 100
	449	#
	450	# $ awk 'BEGIN {x = "75"; y = "100"; x + y; z = x y; if (x > y) {print "75 > 100"} else if (x < y) {print "75 < 100"}}'
	451	# 75 < 100
	452	# $ awk 'BEGIN {x = "75"; y = "100"; z = x y; if (x > y) {print "75 > 100"} else if (x < y) {print "75 < 100"}}'
	453	# 75 > 100