zdv2.bktei.com Git - EVA-2020-02.git/blame_incremental

... / ...

Commit	Line	Data
	1	#!/bin/bash
	2
	3	# Desc: Records gps data until midnight
	4	# Author: Steven Baltakatei Sandoval; License: GPLv3+
	5	# Usage: bkgpslog -o [output dir]
	6
	7	#==BEGIN Define script parameters==
	8	## Logging Behavior parameters
	9	BUFFER_TTL="60"; # time between file writes
	10	SCRIPT_TTL="day"; # (day\|hour)
	11	#### TZ="UTC"; export TZ; # Default time zone; overridden by '--time-zone=[str]' option
	12	DIR_TMP_DEFAULT="/dev/shm"; # Default parent of working directory
	13
	14	SCRIPT_TIME_START=$(date +%Y%m%dT%H%M%S.%N);
	15	PATH="$HOME/.local/bin:$PATH"; # Add "$(systemd-path user-binaries)" path in case apps saved there
	16	SCRIPT_HOSTNAME=$(hostname); # Save hostname of system running this script.
	17	SCRIPT_VERSION="bkgpslog 0.2.0"; # Define version of script.
	18	SCRIPT_NAME="$(basename "$0")"; # Define basename of script file.
	19
	20	declare -Ag appRollCall # Associative array for storing app status
	21	declare -Ag fileRollCall # Associative array for storing file status
	22	declare -Ag dirRollCall # Associative array for storing dir status
	23	declare -a recPubKeys # for processArguments function
	24	declare recipients # for main function
	25
	26	## Initialize variables
	27	OPTION_VERBOSE=""; OPTION_ENCRYPT=""; OPTION_COMPRESS=""; OPTION_TMPDIR="";
	28
	29	#===BEGIN Declare local script functions===
	30	checkapp() {
	31	# Desc: If arg is a command, save result in assoc array 'appRollCall'
	32	# Usage: checkapp arg1 arg2 arg3 ...
	33	# Input: global assoc. array 'appRollCall'
	34	# Output: adds/updates key(value) to global assoc array 'appRollCall'
	35	local returnState
	36	#echo "DEBUG:$(date +%S.%N)..Starting checkapp function."
	37	#echo "DEBUG:args: $@"
	38	#echo "DEBUG:returnState:$returnState"
	39
	40	#===Process Args===
	41	for arg in "$@"; do
	42	#echo "DEBUG:processing arg:$arg"
	43	if command -v "$arg" 1>/dev/null 2>&1; then # Check if arg is a valid command
	44	appRollCall[$arg]="true";
	45	#echo "DEBUG:appRollCall[$arg]:"${appRollCall[$arg]}
	46	if ! [ "$returnState" = "false" ]; then returnState="true"; fi
	47	else
	48	appRollCall[$arg]="false"; returnState="false";
	49	fi
	50	done
	51
	52	#for key in "${!appRollCall[@]}"; do echo "DEBUG:$key => ${appRollCall[$key]}"; done
	53	#echo "DEBUG:evaluating returnstate. returnState:"$returnState
	54
	55	#===Determine function return code===
	56	if [ "$returnState" = "true" ]; then
	57	#echo "DEBUG:checkapp returns true for $arg";
	58	return 0;
	59	else
	60	#echo "DEBUG:checkapp returns false for $arg";
	61	return 1;
	62	fi
	63	} # Check that app exists
	64	checkfile() {
	65	# Desc: If arg is a file path, save result in assoc array 'fileRollCall'
	66	# Usage: checkfile arg1 arg2 arg3 ...
	67	# Input: global assoc. array 'fileRollCall'
	68	# Output: adds/updates key(value) to global assoc array 'fileRollCall';
	69	# Output: returns 0 if app found, 1 otherwise
	70	local returnState
	71
	72	#===Process Args===
	73	for arg in "$@"; do
	74	#echo "DEBUG:processing arg:$arg"
	75	if [ -f "$arg" ]; then
	76	fileRollCall["$arg"]="true";
	77	#echo "DEBUG:fileRollCall[\"$arg\"]:"${fileRollCall["$arg"]}
	78	if ! [ "$returnState" = "false" ]; then returnState="true"; fi
	79	else
	80	fileRollCall["$arg"]="false"; returnState="false";
	81	fi
	82	done
	83
	84	#for key in "${!fileRollCall[@]}"; do echo "DEBUG:fileRollCall key [$key] is:${fileRollCall[$key]}"; done
	85	#echo "DEBUG:evaluating returnstate. returnState:"$returnState
	86
	87	#===Determine function return code===
	88	if [ "$returnState" = "true" ]; then
	89	#echo "DEBUG:checkapp returns true for $arg";
	90	return 0;
	91	else
	92	#echo "DEBUG:checkapp returns false for $arg";
	93	return 1;
	94	fi
	95	} # Check that file exists
	96	checkdir() {
	97	# Desc: If arg is a dir path, save result in assoc array 'dirRollCall'
	98	# Usage: checkdir arg1 arg2 arg3 ...
	99	# Input: global assoc. array 'dirRollCall'
	100	# Output: adds/updates key(value) to global assoc array 'dirRollCall';
	101	# Output: returns 0 if app found, 1 otherwise
	102	local returnState
	103
	104	#===Process Args===
	105	for arg in "$@"; do
	106	#echo "DEBUG:processing arg:$arg"
	107	if [ -d "$arg" ]; then
	108	dirRollCall["$arg"]="true";
	109	#echo "DEBUG:dirRollCall[\"$arg\"]:"${dirRollCall["$arg"]}
	110	if ! [ "$returnState" = "false" ]; then returnState="true"; fi
	111	elif [ "$arg" = "" ]; then
	112	dirRollCall["$arg"]="false"; returnState="false";
	113	else
	114	returnState="false";
	115	fi
	116	done
	117
	118	#for key in "${!dirRollCall[@]}"; do echo "DEBUG:dirRollCall key [$key] is:${dirRollCall[$key]}"; done
	119	#echo "DEBUG:evaluating returnstate. returnState:"$returnState
	120
	121	#===Determine function return code===
	122	if [ "$returnState" = "true" ]; then
	123	#echo "DEBUG:checkapp returns true for $arg";
	124	return 0;
	125	else
	126	#echo "DEBUG:checkapp returns false for $arg";
	127	return 1;
	128	fi
	129	} # Check that dir exists
	130
	131	# Yell, Die, Try Three-Fingered Claw technique
	132	# Ref/Attrib: https://stackoverflow.com/a/25515370
	133	yell() { echo "$0: $*" >&2; }
	134	die() { yell "$*"; exit 111; }
	135	try() { "$@" \|\| die "cannot $*"; }
	136
	137	echoerr() {
	138	echo "$@" 1>&2; # Define stderr echo function.
	139	} # Define stderr message function.
	140	showUsage() {
	141	echoerr "USAGE:"
	142	echoerr " bkgpslog [ options ]"
	143	echoerr
	144	echoerr "OPTIONS:"
	145	echoerr " -h, --help"
	146	echoerr " Display help information."
	147	echoerr
	148	echoerr " --version"
	149	echoerr " Display script version."
	150	echoerr
	151	echoerr " -v, --verbose"
	152	echoerr " Display debugging info."
	153	echoerr
	154	echoerr " -e, --encrypt"
	155	echoerr " Encrypt output."
	156	echoerr
	157	echoerr " -r, --recipient [ pubkey string ]"
	158	echoerr " Specify recipient. May be age or ssh pubkey."
	159	echoerr " See https://github.com/FiloSottile/age"
	160	echoerr
	161	echoerr " -o, --output [ directory ]"
	162	echoerr " Specify output directory to save logs."
	163	echoerr
	164	echoerr " -c, --compress"
	165	echoerr " Compress output with gzip (before encryption if enabled)."
	166	echoerr
	167	echoerr " -z, --time-zone"
	168	echoerr " Specify time zone. (ex: \"America/New_York\")"
	169	echoerr
	170	echoerr " -t, --temp-dir"
	171	echoerr " Specify parent directory for temporary working directory."
	172	echoerr " Default: \"/dev/shm\""
	173	echoerr
	174	echoerr "EXAMPLE: (bash script lines)"
	175	echoerr "/bin/bash bkgpslog -e -c \\"
	176	echoerr "-r age1mrmfnwhtlprn4jquex0ukmwcm7y2nxlphuzgsgv8ew2k9mewy3rs8u7su5 \\"
	177	echoerr "-r age1ala848kqrvxc88rzaauc6vc5v0fqrvef9dxyk79m0vjea3hagclswu0lgq \\"
	178	echoerr "-o ~/Sync/Location"
	179	} # Display information on how to use this script.
	180	showVersion() {
	181	echoerr "$SCRIPT_VERSION"
	182	} # Display script version.
	183	vbm() {
	184	# Usage: vbm "DEBUG:verbose message here"
	185	# Description: Prints verbose message ("vbm") to stderr if OPTION_VERBOSE is set to "true".
	186	# Input:
	187	# - OPTION_VERBOSE variable set by processArguments function. (ex: "true", "false")
	188	# - "$@" positional arguments fed to this function.
	189	# Output: stderr
	190	# Script function dependencies: echoerr
	191	# External function dependencies: echo
	192	# Last modified: 2020-04-11T23:57Z
	193	# Last modified by: Steven Baltakatei Sandoval
	194	# License: GPLv3+
	195	# Ref./Attrib:
	196
	197	if [ "$OPTION_VERBOSE" = "true" ]; then
	198	FUNCTION_TIME=$(date --iso-8601=ns); # Save current time in nano seconds.
	199	echoerr "[$FUNCTION_TIME] ""$*"; # Display argument text.
	200	fi
	201
	202	# End function
	203	return 0; # Function finished.
	204	} # Verbose message display function.
	205	processArguments() {
	206	while [ ! $# -eq 0 ]; do # While number of arguments ($#) is not (!) equal to (-eq) zero (0).
	207	#echoerr "DEBUG:Starting processArguments while loop."
	208	#echoerr "DEBUG:Provided arguments are:""$*"
	209	case "$1" in
	210	-h \| --help) showUsage; exit 1;; # Display usage.
	211	--version) showVersion; exit 1;; # Show version
	212	-v \| --verbose) OPTION_VERBOSE="true"; vbm "DEBUG:Verbose mode enabled.";; # Enable verbose mode.
	213	-o \| --output) if [ -d "$2" ]; then DIR_OUT="$2"; vbm "DEBUG:DIR_OUT:$DIR_OUT"; shift; fi ;; # Define output directory.
	214	-e \| --encrypt) OPTION_ENCRYPT="true"; vbm "DEBUG:Encrypted output mode enabled.";;
	215	-r \| --recipient) # Add 'age' recipient via public key string
	216	recPubKeys+=("$2"); vbm "STATUS:pubkey added:""$2"; shift;;
	217	-c \| --compress) OPTION_COMPRESS="true"; vbm "DEBUG:Compressed output mode enabled.";;
	218	-z \| --time-zone) try setTimeZoneEV "$2"; shift;;
	219	-t \| --temp-dir) OPTION_TMPDIR="true" && TMP_DIR_PRIORITY="$2"; shift;;
	220	) echoerr "ERROR: Unrecognized argument: $1"; echoerr "STATUS:All arguments:$"; exit 1;; # Handle unrecognized options.
	221	esac
	222	shift
	223	done
	224	} # Argument Processing
	225	setTimeZoneEV(){
	226	# Desc: Set time zone environment variable TZ
	227	# Usage: setTimeZoneEV arg1
	228	# Input: arg1: 'date'-compatible timezone string (ex: "America/New_York")
	229	# TZDIR env var (optional; default: "/usr/share/zoneinfo")
	230	# Output: exports TZ
	231	# exit code 0 on success
	232	# exit code 1 on incorrect number of arguments
	233	# exit code 2 if unable to validate arg1
	234	# Depends: yell, printenv, bash 5
	235	# Tested on: Debian 10
	236	ARG1="$1"
	237	local tzDir returnState
	238	if ! [[ $# -eq 1 ]]; then
	239	yell "ERROR:Invalid argument count.";
	240	return 1;
	241	fi
	242
	243	# Read TZDIR env var if available
	244	if printenv TZDIR 1>/dev/null 2>&1; then
	245	tzDir="$(printenv TZDIR)";
	246	else
	247	tzDir="/usr/share/zoneinfo";
	248	fi
	249
	250	# Validate TZ string
	251	if ! [[ -f "$tzDir"/"$ARG1" ]]; then
	252	yell "ERROR:Invalid time zone argument.";
	253	return 2;
	254	else
	255	# Export ARG1 as TZ environment variable
	256	TZ="$ARG1" && export TZ && returnState="true";
	257	fi
	258
	259	# Determine function return code
	260	if [ "$returnState" = "true" ]; then
	261	return 0;
	262	fi
	263	} # Exports TZ environment variable
	264	timeUntilNextDay(){
	265	# Desc: Report seconds until next day.
	266	# Version: 1.0.0
	267	# Output: stdout: integer seconds until next day
	268	# Output: exit code 0 if stdout > 0; 1 if stdout = 0; 2 if stdout < 0
	269	# Usage: timeUntilNextDay
	270	# Usage: if ! myTTL="$(timeUntilNextDay)"; then yell "ERROR in if statement"; exit 1; fi
	271	# Depends: date 8, echo 8, yell, try
	272
	273	local returnState TIME_CURRENT TIME_NEXT_DAY SECONDS_UNTIL_NEXT_DAY
	274
	275	TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
	276	TIME_NEXT_DAY="$(date -d "$TIME_CURRENT next day" --iso-8601=date)"; # Produce timestamp of beginning of tomorrow with resolution of 1 second.
	277	SECONDS_UNTIL_NEXT_DAY="$(( $(date +%s -d "$TIME_NEXT_DAY") - $(date +%s -d "$TIME_CURRENT") ))" ; # Calculate seconds until closest future midnight (res. 1 second).
	278	if [[ "$SECONDS_UNTIL_NEXT_DAY" -gt 0 ]]; then
	279	returnState="true";
	280	elif [[ "$SECONDS_UNTIL_NEXT_DAY" -eq 0 ]]; then
	281	returnState="warning_zero";
	282	yell "WARNING:Reported time until next day exactly zero.";
	283	elif [[ "$SECONDS_UNTIL_NEXT_DAY" -lt 0 ]]; then
	284	returnState="warning_negative";
	285	yell "WARNING:Reported time until next day is negative.";
	286	fi
	287
	288	try echo "$SECONDS_UNTIL_NEXT_DAY"; # Report
	289
	290	# Determine function return code
	291	if [[ "$returnState" = "true" ]]; then
	292	return 0;
	293	elif [[ "$returnState" = "warning_zero" ]]; then
	294	return 1;
	295	elif [[ "$returnState" = "warning_negative" ]]; then
	296	return 2;
	297	fi
	298	} # Report seconds until next day
	299	timeUntilNextHour(){
	300	# Desc: Report seconds until next hour
	301	# Version 1.0.0
	302	# Output: stdout: integer seconds until next hour
	303	# Output: exit code 0 if stdout > 0; 1 if stdout = 0; 2 if stdout < 0
	304	# Usage: timeUntilNextHour
	305	# Usage: if ! myTTL="$(timeUntilNextHour)"; then yell "ERROR in if statement"; exit 1; fi
	306
	307	local returnState TIME_CURRENT TIME_NEXT_HOUR SECONDS_UNTIL_NEXT_HOUR
	308	TIME_CURRENT="$(date --iso-8601=seconds)"; # Produce `date`-parsable current timestamp with resolution of 1 second.
	309	TIME_NEXT_HOUR="$(date -d "$TIME_CURRENT next hour" --iso-8601=hours)"; # Produce `date`-parsable current time stamp with resolution of 1 second.
	310	SECONDS_UNTIL_NEXT_HOUR="$(( $(date +%s -d "$TIME_NEXT_HOUR") - $(date +%s -d "$TIME_CURRENT") ))"; # Calculate seconds until next hour (res. 1 second).
	311	if [[ "$SECONDS_UNTIL_NEXT_HOUR" -gt 0 ]]; then
	312	returnState="true";
	313	elif [[ "$SECONDS_UNTIL_NEXT_HOUR" -eq 0 ]]; then
	314	returnState="warning_zero";
	315	yell "WARNING:Reported time until next hour exactly zero.";
	316	elif [[ "$SECONDS_UNTIL_NEXT_HOUR" -lt 0 ]]; then
	317	returnState="warning_negative";
	318	yell "WARNING:Reported time until next hour is negative.";
	319	fi
	320
	321	try echo "$SECONDS_UNTIL_NEXT_HOUR"; # Report
	322
	323	# Determine function return code
	324	if [[ "$returnState" = "true" ]]; then
	325	return 0;
	326	elif [[ "$returnState" = "warning_zero" ]]; then
	327	return 1;
	328	elif [[ "$returnState" = "warning_negative" ]]; then
	329	return 2;
	330	fi
	331	} # Report seconds until next hour
	332	dateTimeShort(){
	333	# Desc: Timestamp without separators (YYYYmmddTHHMMSS+zzzz)
	334	# Usage: dateTimeShort
	335	# Output: stdout: timestamp (ISO-8601, no separators)
	336	local TIME_CURRENT TIME_CURRENT_SHORT
	337	TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
	338	TIME_CURRENT_SHORT="$(date -d "$TIME_CURRENT" +%Y%m%dT%H%M%S%z)"; # Produce separator-less current timestamp with resolution 1 second.
	339	echo "$TIME_CURRENT_SHORT";
	340	} # Get YYYYmmddTHHMMSS±zzzz
	341	dateShort(){
	342	# Desc: Date without separators (YYYYmmdd)
	343	# Usage: dateShort
	344	# Output: stdout: date (ISO-8601, no separators)
	345	local TIME_CURRENT DATE_CURRENT_SHORT
	346	TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
	347	DATE_CURRENT_SHORT="$(date -d "$TIME_CURRENT" +%Y%m%d)"; # Produce separator-less current date with resolution 1 day.
	348	echo "$DATE_CURRENT_SHORT";
	349	} # Get YYYYmmdd
	350	timeDuration(){
	351	# Desc: Output approximate time duration string before given time (default:current date)
	352	# Ref/Attrib: ISO-8601:2004(E), §4.4.4.2 Representations of time intervals by duration and context information
	353	# Note: "1 month" ("P1M") is assumed to be "30 days" (see ISO-8601:2004(E), §2.2.1.2)
	354	# Usage: timeDuration [arg1] ([arg2])
	355	# Version: 1.0.1
	356	# Input: arg1: seconds as base 10 integer >= 0 (ex: 3601)
	357	# arg2: precision level (optional; default=2)
	358	# Output: stdout: ISO-8601 duration string (ex: "P1H1S", "P2Y10M15DT10H30M20S")
	359	# Example: 'timeDuration 111111 3' yields 'P1DT6H51M'
	360	# Depends: date 8 (gnucoreutils), yell,
	361	local returnState ARG1 ARG2 remainder precision witherPrecision
	362	local fullYears fullMonths fullDays fullHours fullMinutes fullSeconds
	363	local displayYears displayMonths displayDays displayHours displayMinutes displaySeconds
	364	local hasYears hasMonths hasDays hasHours hasMinutes hasSeconds
	365
	366	ARG1="$1";
	367	ARG2="$2";
	368	precision=2; # set default precision
	369	returnState="true"; # set default return state
	370
	371	# Check that between one and two arguments is supplied
	372	if ! { [[ $# -ge 1 ]] && [[ $# -le 2 ]]; }; then
	373	yell "ERROR:Invalid number of arguments:$# . Exiting.";
	374	returnState="ERROR_INPUT"; fi
	375
	376	# Check that arg1 provided
	377	if [[ $# -ge 1 ]]; then
	378	## Check that arg1 is a positive integer
	379	if [[ "$ARG1" =~ ^[[:digit:]]+$ ]]; then
	380	:
	381	else
	382	yell "ERROR:ARG1 not a digit.";
	383	returnState="ERROR_INPUT";
	384	fi
	385	else
	386	yell "ERROR:No argument provided. Exiting.";
	387	exit 1;
	388	fi
	389
	390	# Consider whether arg2 was provided
	391	if [[ $# -eq 2 ]]; then
	392	# Check that the second arg is a positive integer
	393	if [[ "$ARG2" =~ ^[[:digit:]]+$ ]] && [[ "$ARG2" -gt 0 ]]; then
	394	precision="$ARG2";
	395	else
	396	yell "ERROR:ARG2 not a positive integer. (is $ARG2 ). Leaving early.";
	397	returnState="ERROR_INPUT";
	398	fi;
	399	else
	400	:
	401	fi;
	402
	403	remainder="$ARG1" ; # seconds
	404	## Calculate full years Y, update remainder
	405	fullYears=$(( remainder / (3652460*60) ));
	406	remainder=$(( remainder - (fullYears365246060) ));
	407	## Calculate full months M, update remainder
	408	fullMonths=$(( remainder / (302460*60) ));
	409	remainder=$(( remainder - (fullMonths30246060) ));
	410	## Calculate full days D, update remainder
	411	fullDays=$(( remainder / (246060) ));
	412	remainder=$(( remainder - (fullDays2460*60) ));
	413	## Calculate full hours H, update remainder
	414	fullHours=$(( remainder / (60*60) ));
	415	remainder=$(( remainder - (fullHours6060) ));
	416	## Calculate full minutes M, update remainder
	417	fullMinutes=$(( remainder / (60) ));
	418	remainder=$(( remainder - (fullMinutes*60) ));
	419	## Calculate full seconds S, update remainder
	420	fullSeconds=$(( remainder / (1) ));
	421	remainder=$(( remainder - (remainder*1) ));
	422	## Check which fields filled
	423	if [[ $fullYears -gt 0 ]]; then hasYears="true"; else hasYears="false"; fi
	424	if [[ $fullMonths -gt 0 ]]; then hasMonths="true"; else hasMonths="false"; fi
	425	if [[ $fullDays -gt 0 ]]; then hasDays="true"; else hasDays="false"; fi
	426	if [[ $fullHours -gt 0 ]]; then hasHours="true"; else hasHours="false"; fi
	427	if [[ $fullMinutes -gt 0 ]]; then hasMinutes="true"; else hasMinutes="false"; fi
	428	if [[ $fullSeconds -gt 0 ]]; then hasSeconds="true"; else hasSeconds="false"; fi
	429
	430	## Determine which fields to display (see ISO-8601:2004 §4.4.3.2)
	431	witherPrecision="false"
	432
	433	### Years
	434	if $hasYears && [[ $precision -gt 0 ]]; then
	435	displayYears="true";
	436	witherPrecision="true";
	437	else
	438	displayYears="false";
	439	fi;
	440	if $witherPrecision; then ((precision--)); fi;
	441
	442	### Months
	443	if $hasMonths && [[ $precision -gt 0 ]]; then
	444	displayMonths="true";
	445	witherPrecision="true";
	446	else
	447	displayMonths="false";
	448	fi;
	449	if $witherPrecision && [[ $precision -gt 0 ]]; then
	450	displayMonths="true";
	451	fi;
	452	if $witherPrecision; then ((precision--)); fi;
	453
	454	### Days
	455	if $hasDays && [[ $precision -gt 0 ]]; then
	456	displayDays="true";
	457	witherPrecision="true";
	458	else
	459	displayDays="false";
	460	fi;
	461	if $witherPrecision && [[ $precision -gt 0 ]]; then
	462	displayDays="true";
	463	fi;
	464	if $witherPrecision; then ((precision--)); fi;
	465
	466	### Hours
	467	if $hasHours && [[ $precision -gt 0 ]]; then
	468	displayHours="true";
	469	witherPrecision="true";
	470	else
	471	displayHours="false";
	472	fi;
	473	if $witherPrecision && [[ $precision -gt 0 ]]; then
	474	displayHours="true";
	475	fi;
	476	if $witherPrecision; then ((precision--)); fi;
	477
	478	### Minutes
	479	if $hasMinutes && [[ $precision -gt 0 ]]; then
	480	displayMinutes="true";
	481	witherPrecision="true";
	482	else
	483	displayMinutes="false";
	484	fi;
	485	if $witherPrecision && [[ $precision -gt 0 ]]; then
	486	displayMinutes="true";
	487	fi;
	488	if $witherPrecision; then ((precision--)); fi;
	489
	490	### Seconds
	491
	492	if $hasSeconds && [[ $precision -gt 0 ]]; then
	493	displaySeconds="true";
	494	witherPrecision="true";
	495	else
	496	displaySeconds="false";
	497	fi;
	498	if $witherPrecision && [[ $precision -gt 0 ]]; then
	499	displaySeconds="true";
	500	fi;
	501	if $witherPrecision; then ((precision--)); fi;
	502
	503
	504
	505	## Determine whether or not the "T" separator is needed to separate date and time elements
	506	if ( $displayHours \|\| $displayMinutes \|\| $displaySeconds); then
	507	displayDateTime="true"; else displayDateTime="false"; fi
	508
	509	## Construct duration output string
	510	OUTPUT="P"
	511	if $displayYears; then
	512	OUTPUT=$OUTPUT$fullYears"Y"; fi
	513	if $displayMonths; then
	514	OUTPUT=$OUTPUT$fullMonths"M"; fi
	515	if $displayDays; then
	516	OUTPUT=$OUTPUT$fullDays"D"; fi
	517	if $displayDateTime; then
	518	OUTPUT=$OUTPUT"T"; fi
	519	if $displayHours; then
	520	OUTPUT=$OUTPUT$fullHours"H"; fi
	521	if $displayMinutes; then
	522	OUTPUT=$OUTPUT$fullMinutes"M"; fi
	523	if $displaySeconds; then
	524	OUTPUT=$OUTPUT$fullSeconds"S"; fi
	525
	526	## Output duration string to stdout
	527	if [[ "$returnState" = "true" ]]; then echo "$OUTPUT"; fi
	528
	529	#===Determine function return code===
	530	if [ "$returnState" = "true" ]; then
	531	return 0;
	532	else
	533	echo "$returnState" 1>&2;
	534	return 1;
	535	fi
	536
	537	} # Get duration (ex: PT10M4S )
	538	displayMissing() {
	539	# Desc: Displays missing apps, files, and dirs
	540	# Usage: displayMissing
	541	# Input: associative arrays: appRollCall, fileRollCall, dirRollCall
	542	# Output: stderr messages
	543	#==BEGIN Display errors==
	544	#===BEGIN Display Missing Apps===
	545	missingApps="Missing apps :"
	546	#for key in "${!appRollCall[@]}"; do echo "DEBUG:$key => ${appRollCall[$key]}"; done
	547	for key in "${!appRollCall[@]}"; do
	548	value="${appRollCall[$key]}"
	549	if [ "$value" = "false" ]; then
	550	#echo "DEBUG:Missing apps: $key => $value";
	551	missingApps="$missingApps""$key "
	552	appMissing="true"
	553	fi
	554	done
	555	if [ "$appMissing" = "true" ]; then # Only indicate if an app is missing.
	556	echo "$missingApps" 1>&2;
	557	fi
	558	#===END Display Missing Apps===
	559
	560	#===BEGIN Display Missing Files===
	561	missingFiles="Missing files:"
	562	#for key in "${!fileRollCall[@]}"; do echo "DEBUG:$key => ${fileRollCall[$key]}"; done
	563	for key in "${!fileRollCall[@]}"; do
	564	value="${fileRollCall[$key]}"
	565	if [ "$value" = "false" ]; then
	566	#echo "DEBUG:Missing files: $key => $value";
	567	missingFiles="$missingFiles""$key "
	568	fileMissing="true"
	569	fi
	570	done
	571	if [ "$fileMissing" = "true" ]; then # Only indicate if an app is missing.
	572	echo "$missingFiles" 1>&2;
	573	fi
	574	#===END Display Missing Files===
	575
	576	#===BEGIN Display Missing Directories===
	577	missingDirs="Missing dirs:"
	578	#for key in "${!dirRollCall[@]}"; do echo "DEBUG:$key => ${dirRollCall[$key]}"; done
	579	for key in "${!dirRollCall[@]}"; do
	580	value="${dirRollCall[$key]}"
	581	if [ "$value" = "false" ]; then
	582	#echo "DEBUG:Missing dirs: $key => $value";
	583	missingDirs="$missingDirs""$key "
	584	dirMissing="true"
	585	fi
	586	done
	587	if [ "$dirMissing" = "true" ]; then # Only indicate if an dir is missing.
	588	echo "$missingDirs" 1>&2;
	589	fi
	590	#===END Display Missing Directories===
	591
	592	#==END Display errors==
	593	} # Display missing apps, files, dirs
	594	setScriptTTL() {
	595	#Desc: Sets script TTL
	596	#Usage: setScriptTTL arg1
	597	#Input: arg1: "day" or "hour"
	598	#Output: scriptTTL
	599	#Depends: timeUntilNextHour or timeUntilNextDay
	600	local ARG1
	601	ARG1="$1"
	602	if [[ "$ARG1" = "day" ]]; then
	603	# Set script lifespan to end at start of next day
	604	if ! scriptTTL="$(timeUntilNextDay)"; then
	605	if [[ "$scriptTTL" -eq 0 ]]; then
	606	((scriptTTL++)); # Add 1 because 0 would cause 'timeout' to never timeout.
	607	else
	608	yell "ERROR: timeUntilNextDay exit code $?"; exit 1;
	609	fi;
	610	fi;
	611	elif [[ "$ARG1" = "hour" ]]; then
	612	# Set script lifespan to end at start of next hour
	613	if ! scriptTTL="$(timeUntilNextHour)"; then
	614	if [[ "$scriptTTL" -eq 0 ]]; then
	615	((scriptTTL++)); # Add 1 because 0 would cause 'timeout' to never timeout.
	616	else
	617	yell "ERROR: timeUntilNextHour exit code $?"; exit 1;
	618	fi;
	619	fi;
	620	else
	621	yell "ERROR:Invalid argument for setScriptTTL function."; exit 1;
	622	fi
	623	} # Seconds until next (day\|hour).
	624	checkMakeTar() {
	625	# Desc: Checks that a valid tar archive exists, creates one otherwise
	626	# Usage: checkMakeTar [ path ]
	627	# Version: 1.0.1
	628	# Input: arg1: path of tar archive
	629	# Output: exit code 0 : tar readable
	630	# exit code 1 : tar missing; created
	631	# exit code 2 : tar not readable; moved; replaced
	632	# Depends: try, tar, date
	633	local PATH_TAR returnFlag0 returnFlag1 returnFlag2
	634	PATH_TAR="$1"
	635
	636	# Check if file is a valid tar archive
	637	if tar --list --file="$PATH_TAR" 1>/dev/null 2>&1; then
	638	## T1: return success
	639	returnFlag0="tar valid";
	640	else
	641	## F1: Check if file exists
	642	if [[ -f "$PATH_TAR" ]]; then
	643	### T: Rename file
	644	try mv "$PATH_TAR" "$PATH_TAR""--broken--""$(date +%Y%m%dT%H%M%S)" && \
	645	returnFlag1="tar moved";
	646	else
	647	### F: -
	648	:
	649	fi
	650	## F2: Create tar archive, return 0
	651	try tar --create --file="$PATH_TAR" --files-from=/dev/null && \
	652	returnFlag2="tar created";
	653	fi
	654
	655	# Determine function return code
	656	if [[ "$returnFlag0" = "tar valid" ]]; then
	657	return 0;
	658	elif [[ "$returnFlag2" = "tar created" ]] && ! [[ "$returnFlag1" = "tar moved" ]]; then
	659	return 1; # tar missing so created
	660	elif [[ "$returnFlag2" = "tar created" ]] && [[ "$returnFlag1" = "tar moved" ]]; then
	661	return 2; # tar not readable so moved; replaced
	662	fi
	663	} # checks if arg1 is tar; creates one otherwise
	664	appendArgTar(){
	665	# Desc: Writes first argument to temporary file with arguments as options, then appends file to tar
	666	# Usage: writeArg "$(echo "Data to be written.")" [name of file to be inserted] [tar path] [temp dir] ([cmd1] [cmd2] [cmd3] [cmd4]...)
	667	# Input: arg1: data to be written
	668	# arg2: file name of file to be inserted into tar
	669	# arg3: tar archive path (must exist first)
	670	# arg4: temporary working dir
	671	# arg5+: command strings (ex: "gpsbabel -i nmea -f - -o kml -F - ")
	672	# Output: file written to disk
	673	# Example: decrypt multiple large files in parallel
	674	# appendArgTar "$(cat /tmp/largefile1.gpg)" "largefile1" $HOME/archive.tar /tmp "gpg --decrypt" &
	675	# appendArgTar "$(cat /tmp/largefile2.gpg)" "largefile2" $HOME/archive.tar /tmp "gpg --decrypt" &
	676	# appendArgTar "$(cat /tmp/largefile3.gpg)" "largefile3" $HOME/archive.tar /tmp "gpg --decrypt" &
	677	# Depends: bash 5
	678
	679	# Save function name
	680	local FN="${FUNCNAME[0]}"
	681	yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
	682
	683	# Set file name
	684	if ! [ -z "$2" ]; then FILENAME="$2"; else yell "ERROR:$FN:Not enough arguments."; exit 1; fi
	685
	686	# Check tar path is a file
	687	if [ -f "$3" ]; then TAR_PATH="$3"; else yell "ERROR:$FN:Tar archive arg not a file."; exit 1; fi
	688
	689	# Check temp dir arg
	690	if ! [ -z "$4" ]; then TMP_DIR="$4"; else yell "ERROR:$FN:No temporary working dir set."; exit 1; fi
	691
	692	# Set command strings
	693	if ! [ -z "$5" ]; then CMD1="$5"; else CMD1="tee /dev/null "; fi # command string 1
	694	if ! [ -z "$6" ]; then CMD2="$6"; else CMD2="tee /dev/null "; fi # command string 2
	695	if ! [ -z "$7" ]; then CMD3="$7"; else CMD3="tee /dev/null "; fi # command string 3
	696	if ! [ -z "$8" ]; then CMD4="$8"; else CMD4="tee /dev/null "; fi # command string 4
	697
	698	# Debug
	699	yell "STATUS:$FN:CMD1:$CMD1"
	700	yell "STATUS:$FN:CMD2:$CMD2"
	701	yell "STATUS:$FN:CMD3:$CMD3"
	702	yell "STATUS:$FN:CMD4:$CMD4"
	703	yell "STATUS:$FN:FILENAME:$FILENAME"
	704	yell "STATUS:$FN:TAR_PATH:$TAR_PATH"
	705	yell "STATUS:$FN:TMP_DIR:$TMP_DIR"
	706	# Write to temporary working dir
	707	echo "$1" \| $CMD1 \| $CMD2 \| $CMD3 \| $CMD4 > "$TMP_DIR"/"$FILENAME";
	708
	709	# Append to tar
	710	try tar --append --directory="$TMP_DIR" --file="$TAR_PATH" "$FILENAME";
	711	yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
	712	} # Append Bash var to file appended to Tar archive
	713	magicWriteVersion() {
	714	# Desc: Appends time-stamped VERSION to PATHOUT_TAR
	715	# Usage: magicWriteVersion
	716	# Input: CONTENT_VERSION, FILEOUT_VERSION, PATHOUT_TAR, DIR_TMP
	717	# Depends: dateTimeShort, appendArgTar
	718	local CONTENT_VERSION
	719
	720	# Generate VERSION file in BashVar
	721	FILEOUT_VERSION="$(dateTimeShort)..VERSION";
	722	CONTENT_VERSION="VERSION=$SCRIPT_VERSION";
	723	CONTENT_VERSION="$CONTENT_VERSION""\n""SCRIPT_NAME=SCRIPT_NAME";
	724	CONTENT_VERSION="$CONTENT_VERSION""\n""DATE=$(date --iso-8601=seconds)";
	725	CONTENT_VERSION="$CONTENT_VERSION""\n""HOSTNAME=$SCRIPT_HOSTNAME";
	726	CONTENT_VERSION="$(echo -e "$CONTENT_VERSION")"
	727
	728	# Create BashVar as file FILEOUT_VERSION and write-append to PATHOUT_TAR
	729	appendArgTar "$CONTENT_VERSION" "$FILEOUT_VERSION" "$PATHOUT_TAR" "$DIR_TMP";
	730	} # bkgpslog: write version data to PATHOUT_TAR via appendArgTar()
	731	magicWriteBuffer() {
	732	# Desc: bkgpslog-specific meta function for writing data to DIR_TMP then appending each file to PATHOUT_TAR
	733	# Inputs: PATHOUT_TAR FILEOUT_{NMEA,GPX,KML} CMD_CONV_{NMEA,GPX,KML} CMD_{COMPRESS,ENCRYPT} DIR_TMP
	734	# Depends: yell, try, vbm, appendArgTar, tar
	735	local FN="${FUNCNAME[0]}";
	736	wait; # Wait to avoid collision with older magicWriteBuffer() instances (see https://www.tldp.org/LDP/abs/html/x9644.html )
	737	vbm "DEBUG:STATUS:$FN:Started magicWriteBuffer().";
	738
	739	# Validate PATHOUT_TAR as tar.
	740	checkMakeTar "$PATHOUT_TAR";
	741	## Add VERSION file if checkMakeTar had to create a tar (exited 1) or replace one (exited 2)
	742	if [[ $? -eq 1 ]] \|\| [[ $? -eq 2 ]]; then magicWriteVersion; fi
	743
	744	# Write bufferBash to PATHOUT_TAR
	745	appendArgTar "$bufferBash" "$FILEOUT_NMEA" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_NMEA" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write NMEA data
	746	appendArgTar "$bufferBash" "$FILEOUT_GPX" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_GPX" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write GPX file
	747	appendArgTar "$bufferBash" "$FILEOUT_KML" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_KML" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write KML file
	748	# Remove secured chunks from DIR_TMP
	749	try rm "$PATHOUT_NMEA" "$PATHOUT_GPX" "$PATHOUT_KML";
	750	yell "DEBUG:STATUS:$FN:Finished magicWriteBuffer().";
	751	} # bkgpslog write function
	752
	753	main() {
	754	processArguments "$@" # Process arguments.
	755
	756	# Determine working directory
	757	## Set DIR_TMP_PARENT to user-specified value if specified
	758	if [[ "$OPTION_TMPDIR" = "true" ]]; then
	759	if [[ -d "$TMP_DIR_PRIORITY" ]]; then
	760	DIR_TMP_PARENT="$OPTION_TMPDIR";
	761	else
	762	yell "WARNING:Specified temporary working directory not valid:$OPTION_TMPDIR";
	763	exit 1;
	764	fi
	765	fi
	766
	767	## Set DIR_TMP_PARENT to default or fallback otherwise
	768	if [[ -d "$DIR_TMP_DEFAULT" ]]; then
	769	DIR_TMP_PARENT="$DIR_TMP_DEFAULT";
	770	elif [[ -d /tmp ]]; then
	771	yell "WARNING:/dev/shm not available. Falling back to /tmp .";
	772	DIR_TMP_PARENT="/tmp";
	773	else
	774	yell "ERROR:No valid working directory available. Exiting.";
	775	exit 1;
	776	fi
	777
	778	## Set DIR_TMP using DIR_TMP_PARENT and nonce (SCRIPT_TIME_START)
	779	DIR_TMP="$DIR_TMP_PARENT"/"$SCRIPT_TIME_START""..bkgpslog" && vbm "DEBUG:Set DIR_TMP to:$DIR_TMP"; # Note: removed at end of main().
	780
	781	# Set output encryption and compression option strings
	782	if [[ "$OPTION_ENCRYPT" = "true" ]]; then # Check if encryption option active.
	783	if checkapp age; then # Check that age is available.
	784	for pubkey in "${recPubKeys[@]}"; do # Validate recipient pubkey strings by forming test message
	785	vbm "DEBUG:Testing pubkey string:$pubkey"
	786	if echo "butts" \| age -a -r "$pubkey" 1>/dev/null; then
	787	# Form age recipient string
	788	recipients="$recipients""-r $pubkey ";
	789	vbm "STATUS:Added pubkey for forming age recipient string:""$pubkey";
	790	vbm "DEBUG:recipients:""$recipients";
	791	else
	792	yell "ERROR:Exit code ""$?"". Invalid recipient pubkey string. Exiting."; exit 1;
	793	fi
	794	done
	795	vbm "DEBUG:Finished processing recPubKeys array";
	796	# Form age command string
	797	CMD_ENCRYPT="age ""$recipients ";
	798	CMD_ENCRYPT_SUFFIX=".age";
	799	else
	800	yell "ERROR:Encryption enabled but \"age\" not found. Exiting."; exit 1;
	801	fi
	802	else
	803	CMD_ENCRYPT="tee /dev/null ";
	804	CMD_ENCRYPT_SUFFIX="";
	805	vbm "DEBUG:Encryption not enabled."
	806	fi
	807	if [[ "$OPTION_COMPRESS" = "true" ]]; then # Check if compression option active
	808	if checkapp gzip; then # Check if gzip available
	809	CMD_COMPRESS="gzip ";
	810	CMD_COMPRESS_SUFFIX=".gz";
	811	else
	812	yell "ERROR:Compression enabled but \"gzip\" not found. Exiting."; exit 1;
	813	fi
	814	else
	815	CMD_COMPRESS="tee /dev/null ";
	816	CMD_COMPRESS_SUFFIX="";
	817	vbm "DEBUG:Compression not enabled.";
	818	fi
	819
	820	# Check that critical apps and dirs are available, displag missing ones.
	821	if ! checkapp gpspipe tar && ! checkdir "$DIR_OUT" "/dev/shm"; then
	822	yell "ERROR:Critical components missing.";
	823	displayMissing; yell "Exiting."; exit 1; fi
	824
	825	# Set script lifespan
	826	setScriptTTL "$SCRIPT_TTL"; # seconds until next new SCRIPT_TTL (ex: "day" or "hour")
	827
	828	# File name substring: encoded bufferTTL
	829	bufferTTL_STR="$(timeDuration $BUFFER_TTL)";
	830
	831	# Init temp working dir
	832	try mkdir "$DIR_TMP" && vbm "DEBUG:Working dir creatd at:$DIR_TMP";
	833
	834	# Initialize 'tar' archive
	835	## Define output tar path (note: each day gets one tar file (Ex: "20200731..hostname_location.[.gpx.gz].tar"))
	836	PATHOUT_TAR="$DIR_OUT"/"$(dateShort)".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
	837	vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
	838	## Check that PATHOUT_TAR is a tar. Rename old and create empty one otherwise.
	839	checkMakeTar "$PATHOUT_TAR" && vbm "DEBUG:Confirmed or Created to be a tar:$PATHOUT_TAR";
	840	## Append VERSION file to PATHOUT_TAR
	841	magicWriteVersion;
	842
	843	# Record gps data until script lifespan ends
	844	declare debugCounter; debugCounter="0"; # set debug counter
	845	while [[ "$SECONDS" -lt "$scriptTTL" ]]; do
	846	timeBufferStart="$(dateTimeShort)"; # Note start time
	847	# Determine file paths (time is start of buffer period)
	848	FILEOUT_BASENAME="$timeBufferStart""--""$bufferTTL_STR""..""$SCRIPT_HOSTNAME""_location" && vbm "STATUS:Set FILEOUT_BASENAME to:$FILEOUT_BASENAME";
	849	## Files saved to DIR_TMP
	850	FILEOUT_NMEA="$FILEOUT_BASENAME".nmea"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_NMEA to:$FILEOUT_NMEA";
	851	FILEOUT_GPX="$FILEOUT_BASENAME".gpx"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_GPX to:$FILEOUT_GPX";
	852	FILEOUT_KML="$FILEOUT_BASENAME".kml"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_KML to:$FILEOUT_KML";
	853	PATHOUT_NMEA="$DIR_TMP"/"$FILEOUT_NMEA" && vbm "STATUS:Set PATHOUT_NMEA to:$PATHOUT_NMEA";
	854	PATHOUT_GPX="$DIR_TMP"/"$FILEOUT_GPX" && vbm "STATUS:Set PATHOUT_GPX to:$PATHOUT_GPX";
	855	PATHOUT_KML="$DIR_TMP"/"$FILEOUT_KML" && vbm "STATUS:Set PATHOUT_KML to:$PATHOUT_KML";
	856	## Files saved to disk (DIR_OUT)
	857	### one file per day (Ex: "20200731..hostname_location.[.gpx.gz].tar")
	858	PATHOUT_TAR="$DIR_OUT"/"$(dateShort)".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
	859	vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
	860	# Define GPS conversion commands
	861	CMD_CONV_NMEA="tee /dev/null " && vbm "STATUS:Set CMD_CONV_NMEA to:$CMD_CONV_NMEA"; # tee as passthrough
	862	CMD_CONV_GPX="gpsbabel -i nmea -f - -o gpx -F - " && vbm "STATUS:Set CMD_CONV_GPX to:$CMD_CONV_GPX"; # convert NMEA to GPX
	863	CMD_CONV_KML="gpsbabel -i nmea -f - -o kml -F - " && vbm "STATUS:Set CMD_CONV_KML to:$CMD_CONV_KML"; # convert NMEA to KML
	864	# Fill Bash variable buffer
	865	bufferBash="$(timeout "$BUFFER_TTL""s" gpspipe -r)" && vbm "STATUS:Successfully filled bufferBash variable with gpspipe data."; # Record gpspipe nmea data to buffer for bufferTTL seconds
	866	# Process bufferBash, save secured chunk set to DIR_TMP
	867	vbm "STATUS:Beginning to save data to $DIR_TMP";
	868	magicWriteBuffer &
	869	# Append each secured chunk in memory dir (DIR_TMP) to file on disk (PATHOUT_TAR in DIR_OUT)
	870	vbm "STATUS:DIR_TMP :$DIR_TMP";
	871	vbm "STATUS:PATHOUT_TAR :$PATHOUT_TAR";
	872	vbm "STATUS:PATHOUT_NMEA:$PATHOUT_NMEA";
	873	vbm "STATUS:PATHOUT_GPX:$PATHOUT_GPX";
	874	vbm "STATUS:PATHOUT_KML:$PATHOUT_KML";
	875
	876	# Reset buffer and filenames
	877	unset bufferBash FILEOUT_BASENAME PATHOUT_NMEA PATHOUT_GPX PATHOUT_KML PATHOUT_TAR timeBufferStart;
	878	vbm "DEBUG:Completed buffer session $debugCounter ." 1>&2;
	879	((debugCounter++))
	880	done
	881
	882	# Remove DIR_TMP
	883	try rm -r "$DIR_TMP";
	884
	885	vbm "STATUS:Main function finished.";
	886	} # Main function.
	887	#===END Declare local script functions===
	888	#==END Define script parameters==
	889
	890
	891	#==BEGIN Perform work and exit==
	892	main "$@" # Run main function.
	893	exit 0;
	894	#==END Perform work and exit==