projects / EVA-2020-02.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
test(bkgpslog):debug:Shift magicBufferSleepPID
[EVA-2020-02.git] / exec / bkgpslog
... / ...
CommitLineData
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
9BUFFER_TTL="300"; # time between file writes
10SCRIPT_TTL_TE="day"; # (day|hour)
11#### TZ="UTC"; export TZ; # Default time zone; overridden by '--time-zone=[str]' option
12DIR_TMP_DEFAULT="/dev/shm"; # Default parent of working directory
13
14SCRIPT_TIME_START=$(date +%Y%m%dT%H%M%S.%N);
15PATH="$HOME/.local/bin:$PATH"; # Add "$(systemd-path user-binaries)" path in case apps saved there
16SCRIPT_HOSTNAME=$(hostname); # Save hostname of system running this script.
17SCRIPT_VERSION="0.4.4-alpha"; # Define version of script.
18SCRIPT_NAME="bkgpslog"; # Define basename of script file.
19SCRIPT_URL="https://gitlab.com/baltakatei/ninfacyzga-01"; # Define wesite hosting this script.
20AGE_VERSION="1.0.0-beta2"; # Define version of age (encryption program)
21AGE_URL="https://github.com/FiloSottile/age/releases/tag/v1.0.0-beta2"; # Define website hosting age.
22
23declare -Ag appRollCall # Associative array for storing app status
24declare -Ag fileRollCall # Associative array for storing file status
25declare -Ag dirRollCall # Associative array for storing dir status
26declare -a argRecPubKeys # for processArguments function
27# declare -a errorHistory # for correcting buffer lag
28
29## Initialize variables
30OPTION_VERBOSE=""; OPTION_ENCRYPT=""; OPTION_COMPRESS=""; OPTION_TMPDIR="";
31errResetx10e3=0; BUFFER_TTL_ADJ_FLOAT="";
32### PID Control factors
33K_P=10; # Gain for compensating buffer round lag
34T_I=2; # Consider this number of past buffer rounds to eliminate error
35T_D=1; # Predict value this number of buffer rounds into the future
36
37#===BEGIN Declare local script functions===
38checkapp() {
39 # Desc: If arg is a command, save result in assoc array 'appRollCall'
40 # Usage: checkapp arg1 arg2 arg3 ...
41 # Input: global assoc. array 'appRollCall'
42 # Output: adds/updates key(value) to global assoc array 'appRollCall'
43 local returnState
44 #echo "DEBUG:$(date +%S.%N)..Starting checkapp function."
45 #echo "DEBUG:args: $@"
46 #echo "DEBUG:returnState:$returnState"
47
48 #===Process Args===
49 for arg in "$@"; do
50 #echo "DEBUG:processing arg:$arg"
51 if command -v "$arg" 1>/dev/null 2>&1; then # Check if arg is a valid command
52 appRollCall[$arg]="true";
53 #echo "DEBUG:appRollCall[$arg]:"${appRollCall[$arg]}
54 if ! [ "$returnState" = "false" ]; then returnState="true"; fi
55 else
56 appRollCall[$arg]="false"; returnState="false";
57 fi
58 done
59
60 #for key in "${!appRollCall[@]}"; do echo "DEBUG:$key => ${appRollCall[$key]}"; done
61 #echo "DEBUG:evaluating returnstate. returnState:"$returnState
62
63 #===Determine function return code===
64 if [ "$returnState" = "true" ]; then
65 #echo "DEBUG:checkapp returns true for $arg";
66 return 0;
67 else
68 #echo "DEBUG:checkapp returns false for $arg";
69 return 1;
70 fi
71} # Check that app exists
72checkfile() {
73 # Desc: If arg is a file path, save result in assoc array 'fileRollCall'
74 # Usage: checkfile arg1 arg2 arg3 ...
75 # Input: global assoc. array 'fileRollCall'
76 # Output: adds/updates key(value) to global assoc array 'fileRollCall';
77 # Output: returns 0 if app found, 1 otherwise
78 local returnState
79
80 #===Process Args===
81 for arg in "$@"; do
82 #echo "DEBUG:processing arg:$arg"
83 if [ -f "$arg" ]; then
84 fileRollCall["$arg"]="true";
85 #echo "DEBUG:fileRollCall[\"$arg\"]:"${fileRollCall["$arg"]}
86 if ! [ "$returnState" = "false" ]; then returnState="true"; fi
87 else
88 fileRollCall["$arg"]="false"; returnState="false";
89 fi
90 done
91
92 #for key in "${!fileRollCall[@]}"; do echo "DEBUG:fileRollCall key [$key] is:${fileRollCall[$key]}"; done
93 #echo "DEBUG:evaluating returnstate. returnState:"$returnState
94
95 #===Determine function return code===
96 if [ "$returnState" = "true" ]; then
97 #echo "DEBUG:checkapp returns true for $arg";
98 return 0;
99 else
100 #echo "DEBUG:checkapp returns false for $arg";
101 return 1;
102 fi
103} # Check that file exists
104checkdir() {
105 # Desc: If arg is a dir path, save result in assoc array 'dirRollCall'
106 # Usage: checkdir arg1 arg2 arg3 ...
107 # Input: global assoc. array 'dirRollCall'
108 # Output: adds/updates key(value) to global assoc array 'dirRollCall';
109 # Output: returns 0 if app found, 1 otherwise
110 local returnState
111
112 #===Process Args===
113 for arg in "$@"; do
114 #echo "DEBUG:processing arg:$arg"
115 if [ -d "$arg" ]; then
116 dirRollCall["$arg"]="true";
117 #echo "DEBUG:dirRollCall[\"$arg\"]:"${dirRollCall["$arg"]}
118 if ! [ "$returnState" = "false" ]; then returnState="true"; fi
119 elif [ "$arg" = "" ]; then
120 dirRollCall["$arg"]="false"; returnState="false";
121 else
122 returnState="false";
123 fi
124 done
125
126 #for key in "${!dirRollCall[@]}"; do echo "DEBUG:dirRollCall key [$key] is:${dirRollCall[$key]}"; done
127 #echo "DEBUG:evaluating returnstate. returnState:"$returnState
128
129 #===Determine function return code===
130 if [ "$returnState" = "true" ]; then
131 #echo "DEBUG:checkapp returns true for $arg";
132 return 0;
133 else
134 #echo "DEBUG:checkapp returns false for $arg";
135 return 1;
136 fi
137} # Check that dir exists
138
139# Yell, Die, Try Three-Fingered Claw technique
140# Ref/Attrib: https://stackoverflow.com/a/25515370
141yell() { echo "$0: $*" >&2; }
142die() { yell "$*"; exit 111; }
143try() { "$@" || die "cannot $*"; }
144
145echoerr() {
146 echo "$@" 1>&2; # Define stderr echo function.
147} # Define stderr message function.
148showUsage() {
149 echoerr "USAGE:"
150 echoerr " bkgpslog [ options ]"
151 echoerr
152 echoerr "OPTIONS:"
153 echoerr " -h, --help"
154 echoerr " Display help information."
155 echoerr " --version"
156 echoerr " Display script version."
157 echoerr " -v, --verbose"
158 echoerr " Display debugging info."
159 echoerr " -e, --encrypt"
160 echoerr " Encrypt output."
161 echoerr " -r, --recipient [ string pubkey ]"
162 echoerr " Specify recipient. May be age or ssh pubkey."
163 echoerr " May be specified multiple times for multiple pubkeys."
164 echoerr " See https://github.com/FiloSottile/age"
165 echoerr " -o, --output [ path dir ]"
166 echoerr " Specify output directory to save logs."
167 echoerr " -c, --compress"
168 echoerr " Compress output with gzip (before encryption if enabled)."
169 echoerr " -z, --time-zone"
170 echoerr " Specify time zone. (ex: \"America/New_York\")"
171 echoerr " -t, --temp-dir [path dir]"
172 echoerr " Specify parent directory for temporary working directory."
173 echoerr " Default: \"/dev/shm\""
174 echoerr " -R, --recipient-dir [path dir]"
175 echoerr " Specify directory containing files whose first lines are"
176 echoerr " to be interpreted as pubkey strings (see \\'-r\\' option)."
177 echoerr " -b, --buffer-ttl [integer]"
178 echoerr " Specify custom buffer period in seconds (default: 300 seconds)"
179 echoerr " -B, --script-ttl [integer]"
180 echoerr " Specify custom script time-to-live in seconds (default: \"day\")"
181 echoerr
182 echoerr "EXAMPLE: (bash script lines)"
183 echoerr "/bin/bash bkgpslog -v -e -c \\"
184 echoerr "-z \"UTC\" -t \"/dev/shm\" \\"
185 echoerr "-r age1mrmfnwhtlprn4jquex0ukmwcm7y2nxlphuzgsgv8ew2k9mewy3rs8u7su5 \\"
186 echoerr "-r age1ala848kqrvxc88rzaauc6vc5v0fqrvef9dxyk79m0vjea3hagclswu0lgq \\"
187 echoerr "-o ~/Sync/Location"
188} # Display information on how to use this script.
189showVersion() {
190 echoerr "$SCRIPT_VERSION"
191} # Display script version.
192vbm() {
193 # Usage: vbm "DEBUG:verbose message here"
194 # Description: Prints verbose message ("vbm") to stderr if OPTION_VERBOSE is set to "true".
195 # Input:
196 # - OPTION_VERBOSE variable set by processArguments function. (ex: "true", "false")
197 # - "$@" positional arguments fed to this function.
198 # Output: stderr
199 # Script function dependencies: echoerr
200 # External function dependencies: echo
201 # Last modified: 2020-04-11T23:57Z
202 # Last modified by: Steven Baltakatei Sandoval
203 # License: GPLv3+
204 # Ref./Attrib:
205
206 if [ "$OPTION_VERBOSE" = "true" ]; then
207 FUNCTION_TIME=$(date --iso-8601=ns); # Save current time in nano seconds.
208 echoerr "[$FUNCTION_TIME] ""$*"; # Display argument text.
209 fi
210
211 # End function
212 return 0; # Function finished.
213} # Verbose message display function.
214processArguments() {
215 while [ ! $# -eq 0 ]; do # While number of arguments ($#) is not (!) equal to (-eq) zero (0).
216 #echoerr "DEBUG:Starting processArguments while loop."
217 #echoerr "DEBUG:Provided arguments are:""$*"
218 case "$1" in
219 -h | --help) showUsage; exit 1;; # Display usage.
220 --version) showVersion; exit 1;; # Show version
221 -v | --verbose) OPTION_VERBOSE="true"; vbm "DEBUG:Verbose mode enabled.";; # Enable verbose mode.
222 -o | --output) if [ -d "$2" ]; then DIR_OUT="$2"; vbm "DEBUG:DIR_OUT:$DIR_OUT"; shift; fi ;; # Define output directory.
223 -e | --encrypt) OPTION_ENCRYPT="true"; vbm "DEBUG:Encrypted output mode enabled.";; # Enable encryption
224 -r | --recipient) OPTION_RECIPIENTS="true"; argRecPubKeys+=("$2"); vbm "STATUS:pubkey added:""$2"; shift;; # Add recipients
225 -c | --compress) OPTION_COMPRESS="true"; vbm "DEBUG:Compressed output mode enabled.";; # Enable compression
226 -z | --time-zone) try setTimeZoneEV "$2"; shift;; # Set timestamp timezone
227 -t | --temp-dir) OPTION_TMPDIR="true" && argTempDirPriority="$2"; shift;; # Set time zone
228 -R | --recipient-dir) OPTION_RECIPIENTS="true"; OPTION_RECDIR="true" && argRecDir="$2"; shift;; # Add recipient watch dir
229 -b | --buffer-ttl) OPTION_CUSTOM_BUFFERTTL="true" && argCustomBufferTTL="$2"; shift;; # Set custom buffer period (default: 300 seconds)
230 -B | --script-ttl) OPTION_CUSTOM_SCRIPTTTL_TE="true" && argCustomScriptTTL="$2"; shift;; # Set custom script TTL (default: "day")
231 *) echoerr "ERROR: Unrecognized argument: $1"; echoerr "STATUS:All arguments:$*"; exit 1;; # Handle unrecognized options.
232 esac
233 shift
234 done
235} # Argument Processing
236setTimeZoneEV(){
237 # Desc: Set time zone environment variable TZ
238 # Usage: setTimeZoneEV arg1
239 # Input: arg1: 'date'-compatible timezone string (ex: "America/New_York")
240 # TZDIR env var (optional; default: "/usr/share/zoneinfo")
241 # Output: exports TZ
242 # exit code 0 on success
243 # exit code 1 on incorrect number of arguments
244 # exit code 2 if unable to validate arg1
245 # Depends: yell, printenv, bash 5
246 # Tested on: Debian 10
247 ARG1="$1"
248 local tzDir returnState
249 if ! [[ $# -eq 1 ]]; then
250 yell "ERROR:Invalid argument count.";
251 return 1;
252 fi
253
254 # Read TZDIR env var if available
255 if printenv TZDIR 1>/dev/null 2>&1; then
256 tzDir="$(printenv TZDIR)";
257 else
258 tzDir="/usr/share/zoneinfo";
259 fi
260
261 # Validate TZ string
262 if ! [[ -f "$tzDir"/"$ARG1" ]]; then
263 yell "ERROR:Invalid time zone argument.";
264 return 2;
265 else
266 # Export ARG1 as TZ environment variable
267 TZ="$ARG1" && export TZ && returnState="true";
268 fi
269
270 # Determine function return code
271 if [ "$returnState" = "true" ]; then
272 return 0;
273 fi
274} # Exports TZ environment variable
275timeUntilNextDay(){
276 # Desc: Report seconds until next day.
277 # Version: 1.0.0
278 # Output: stdout: integer seconds until next day
279 # Output: exit code 0 if stdout > 0; 1 if stdout = 0; 2 if stdout < 0
280 # Usage: timeUntilNextDay
281 # Usage: if ! myTTL="$(timeUntilNextDay)"; then yell "ERROR in if statement"; exit 1; fi
282 # Depends: date 8, echo 8, yell, try
283
284 local returnState TIME_CURRENT TIME_NEXT_DAY SECONDS_UNTIL_NEXT_DAY
285
286 TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
287 TIME_NEXT_DAY="$(date -d "$TIME_CURRENT next day" --iso-8601=date)"; # Produce timestamp of beginning of tomorrow with resolution of 1 second.
288 SECONDS_UNTIL_NEXT_DAY="$(( $(date +%s -d "$TIME_NEXT_DAY") - $(date +%s -d "$TIME_CURRENT") ))" ; # Calculate seconds until closest future midnight (res. 1 second).
289 if [[ "$SECONDS_UNTIL_NEXT_DAY" -gt 0 ]]; then
290 returnState="true";
291 elif [[ "$SECONDS_UNTIL_NEXT_DAY" -eq 0 ]]; then
292 returnState="warning_zero";
293 yell "WARNING:Reported time until next day exactly zero.";
294 elif [[ "$SECONDS_UNTIL_NEXT_DAY" -lt 0 ]]; then
295 returnState="warning_negative";
296 yell "WARNING:Reported time until next day is negative.";
297 fi
298
299 try echo "$SECONDS_UNTIL_NEXT_DAY"; # Report
300
301 # Determine function return code
302 if [[ "$returnState" = "true" ]]; then
303 return 0;
304 elif [[ "$returnState" = "warning_zero" ]]; then
305 return 1;
306 elif [[ "$returnState" = "warning_negative" ]]; then
307 return 2;
308 fi
309} # Report seconds until next day
310timeUntilNextHour(){
311 # Desc: Report seconds until next hour
312 # Version 1.0.0
313 # Output: stdout: integer seconds until next hour
314 # Output: exit code 0 if stdout > 0; 1 if stdout = 0; 2 if stdout < 0
315 # Usage: timeUntilNextHour
316 # Usage: if ! myTTL="$(timeUntilNextHour)"; then yell "ERROR in if statement"; exit 1; fi
317
318 local returnState TIME_CURRENT TIME_NEXT_HOUR SECONDS_UNTIL_NEXT_HOUR
319 TIME_CURRENT="$(date --iso-8601=seconds)"; # Produce `date`-parsable current timestamp with resolution of 1 second.
320 TIME_NEXT_HOUR="$(date -d "$TIME_CURRENT next hour" --iso-8601=hours)"; # Produce `date`-parsable current time stamp with resolution of 1 second.
321 SECONDS_UNTIL_NEXT_HOUR="$(( $(date +%s -d "$TIME_NEXT_HOUR") - $(date +%s -d "$TIME_CURRENT") ))"; # Calculate seconds until next hour (res. 1 second).
322 if [[ "$SECONDS_UNTIL_NEXT_HOUR" -gt 0 ]]; then
323 returnState="true";
324 elif [[ "$SECONDS_UNTIL_NEXT_HOUR" -eq 0 ]]; then
325 returnState="warning_zero";
326 yell "WARNING:Reported time until next hour exactly zero.";
327 elif [[ "$SECONDS_UNTIL_NEXT_HOUR" -lt 0 ]]; then
328 returnState="warning_negative";
329 yell "WARNING:Reported time until next hour is negative.";
330 fi
331
332 try echo "$SECONDS_UNTIL_NEXT_HOUR"; # Report
333
334 # Determine function return code
335 if [[ "$returnState" = "true" ]]; then
336 return 0;
337 elif [[ "$returnState" = "warning_zero" ]]; then
338 return 1;
339 elif [[ "$returnState" = "warning_negative" ]]; then
340 return 2;
341 fi
342} # Report seconds until next hour
343dateTimeShort(){
344 # Desc: Timestamp without separators (YYYYmmddTHHMMSS+zzzz)
345 # Usage: dateTimeShort ([str date])
346 # Version 1.1.0
347 # Input: arg1: 'date'-parsable timestamp string (optional)
348 # Output: stdout: timestamp (ISO-8601, no separators)
349 # Depends: yell
350 local TIME_CURRENT TIME_CURRENT_SHORT
351
352 argTime="$1";
353 # Get Current Time
354 TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
355 # Decide to parse current or supplied date
356 ## Check if time argument empty
357 if [[ -z "$argTime" ]]; then
358 ## T: Time argument empty, use current time
359 TIME_INPUT="$TIME_CURRENT";
360 else
361 ## F: Time argument exists, validate time
362 if date --date="$argTime" 1>/dev/null 2>&1; then
363 ### T: Time argument is valid; use it
364 TIME_INPUT="$argTime";
365 else
366 ### F: Time argument not valid; exit
367 yell "ERROR:Invalid time argument supplied. Exiting."; exit 1;
368 fi
369 fi
370 # Construct and deliver separator-les date string
371 TIME_CURRENT_SHORT="$(date -d "$TIME_INPUT" +%Y%m%dT%H%M%S%z)";
372 echo "$TIME_CURRENT_SHORT";
373} # Get YYYYmmddTHHMMSS±zzzz
374dateShort(){
375 # Desc: Date without separators (YYYYmmdd)
376 # Usage: dateShort ([str date])
377 # Version: 1.1.0
378 # Input: arg1: 'date'-parsable timestamp string (optional)
379 # Output: stdout: date (ISO-8601, no separators)
380 # Depends: yell
381 local TIME_CURRENT DATE_CURRENT_SHORT
382
383 argTime="$1";
384 # Get Current Time
385 TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
386 # Decide to parse current or supplied date
387 ## Check if time argument empty
388 if [[ -z "$argTime" ]]; then
389 ## T: Time argument empty, use current time
390 TIME_INPUT="$TIME_CURRENT";
391 else
392 ## F: Time argument exists, validate time
393 if date --date="$argTime" 1>/dev/null 2>&1; then
394 ### T: Time argument is valid; use it
395 TIME_INPUT="$argTime";
396 else
397 ### F: Time argument not valid; exit
398 yell "ERROR:Invalid time argument supplied. Exiting."; exit 1;
399 fi
400 fi
401 # Construct and deliver separator-les date string
402 DATE_CURRENT_SHORT="$(date -d "$TIME_INPUT" +%Y%m%d)"; # Produce separator-less current date with resolution 1 day.
403 echo "$DATE_CURRENT_SHORT";
404} # Get YYYYmmdd
405timeDuration(){
406 # Desc: Given seconds, output ISO-8601 duration string
407 # Ref/Attrib: ISO-8601:2004(E), §4.4.4.2 Representations of time intervals by duration and context information
408 # Note: "1 month" ("P1M") is assumed to be "30 days" (see ISO-8601:2004(E), §2.2.1.2)
409 # Usage: timeDuration [1:seconds] ([2:precision])
410 # Version: 1.0.3
411 # Input: arg1: seconds as base 10 integer >= 0 (ex: 3601)
412 # arg2: precision level (optional; default=2)
413 # Output: stdout: ISO-8601 duration string (ex: "P1H1S", "P2Y10M15DT10H30M20S")
414 # exit code 0: success
415 # exit code 1: error_input
416 # exit code 2: error_unknown
417 # Example: 'timeDuration 111111 3' yields 'P1DT6H51M'
418 # Depends: date 8 (gnucoreutils), yell,
419 local returnState argSeconds argPrecision remainder precision witherPrecision
420 local fullYears fullMonths fullDays fullHours fullMinutes fullSeconds
421 local displayYears displayMonths displayDays displayHours displayMinutes displaySeconds
422 local hasYears hasMonths hasDays hasHours hasMinutes hasSeconds
423
424 argSeconds="$1"; # read arg1 (seconds)
425 argPrecision="$2"; # read arg2 (precision)
426 precision=2; # set default precision
427
428 # Check that between one and two arguments is supplied
429 if ! { [[ $# -ge 1 ]] && [[ $# -le 2 ]]; }; then
430 yell "ERROR:Invalid number of arguments:$# . Exiting.";
431 returnState="error_input"; fi
432
433 # Check that argSeconds provided
434 if [[ $# -ge 1 ]]; then
435 ## Check that argSeconds is a positive integer
436 if [[ "$argSeconds" =~ ^[[:digit:]]+$ ]]; then
437 :
438 else
439 yell "ERROR:argSeconds not a digit.";
440 returnState="error_input";
441 fi
442 else
443 yell "ERROR:No argument provided. Exiting.";
444 exit 1;
445 fi
446
447 # Consider whether argPrecision was provided
448 if [[ $# -eq 2 ]]; then
449 # Check that argPrecision is a positive integer
450 if [[ "$argPrecision" =~ ^[[:digit:]]+$ ]] && [[ "$argPrecision" -gt 0 ]]; then
451 precision="$argPrecision";
452 else
453 yell "ERROR:argPrecision not a positive integer. (is $argPrecision ). Leaving early.";
454 returnState="error_input";
455 fi;
456 else
457 :
458 fi;
459
460 remainder="$argSeconds" ; # seconds
461 ## Calculate full years Y, update remainder
462 fullYears=$(( remainder / (365*24*60*60) ));
463 remainder=$(( remainder - (fullYears*365*24*60*60) ));
464 ## Calculate full months M, update remainder
465 fullMonths=$(( remainder / (30*24*60*60) ));
466 remainder=$(( remainder - (fullMonths*30*24*60*60) ));
467 ## Calculate full days D, update remainder
468 fullDays=$(( remainder / (24*60*60) ));
469 remainder=$(( remainder - (fullDays*24*60*60) ));
470 ## Calculate full hours H, update remainder
471 fullHours=$(( remainder / (60*60) ));
472 remainder=$(( remainder - (fullHours*60*60) ));
473 ## Calculate full minutes M, update remainder
474 fullMinutes=$(( remainder / (60) ));
475 remainder=$(( remainder - (fullMinutes*60) ));
476 ## Calculate full seconds S, update remainder
477 fullSeconds=$(( remainder / (1) ));
478 remainder=$(( remainder - (remainder*1) ));
479 ## Check which fields filled
480 if [[ $fullYears -gt 0 ]]; then hasYears="true"; else hasYears="false"; fi
481 if [[ $fullMonths -gt 0 ]]; then hasMonths="true"; else hasMonths="false"; fi
482 if [[ $fullDays -gt 0 ]]; then hasDays="true"; else hasDays="false"; fi
483 if [[ $fullHours -gt 0 ]]; then hasHours="true"; else hasHours="false"; fi
484 if [[ $fullMinutes -gt 0 ]]; then hasMinutes="true"; else hasMinutes="false"; fi
485 if [[ $fullSeconds -gt 0 ]]; then hasSeconds="true"; else hasSeconds="false"; fi
486
487 ## Determine which fields to display (see ISO-8601:2004 §4.4.3.2)
488 witherPrecision="false"
489
490 ### Years
491 if $hasYears && [[ $precision -gt 0 ]]; then
492 displayYears="true";
493 witherPrecision="true";
494 else
495 displayYears="false";
496 fi;
497 if $witherPrecision; then ((precision--)); fi;
498
499 ### Months
500 if $hasMonths && [[ $precision -gt 0 ]]; then
501 displayMonths="true";
502 witherPrecision="true";
503 else
504 displayMonths="false";
505 fi;
506 if $witherPrecision && [[ $precision -gt 0 ]]; then
507 displayMonths="true";
508 fi;
509 if $witherPrecision; then ((precision--)); fi;
510
511 ### Days
512 if $hasDays && [[ $precision -gt 0 ]]; then
513 displayDays="true";
514 witherPrecision="true";
515 else
516 displayDays="false";
517 fi;
518 if $witherPrecision && [[ $precision -gt 0 ]]; then
519 displayDays="true";
520 fi;
521 if $witherPrecision; then ((precision--)); fi;
522
523 ### Hours
524 if $hasHours && [[ $precision -gt 0 ]]; then
525 displayHours="true";
526 witherPrecision="true";
527 else
528 displayHours="false";
529 fi;
530 if $witherPrecision && [[ $precision -gt 0 ]]; then
531 displayHours="true";
532 fi;
533 if $witherPrecision; then ((precision--)); fi;
534
535 ### Minutes
536 if $hasMinutes && [[ $precision -gt 0 ]]; then
537 displayMinutes="true";
538 witherPrecision="true";
539 else
540 displayMinutes="false";
541 fi;
542 if $witherPrecision && [[ $precision -gt 0 ]]; then
543 displayMinutes="true";
544 fi;
545 if $witherPrecision; then ((precision--)); fi;
546
547 ### Seconds
548
549 if $hasSeconds && [[ $precision -gt 0 ]]; then
550 displaySeconds="true";
551 witherPrecision="true";
552 else
553 displaySeconds="false";
554 fi;
555 if $witherPrecision && [[ $precision -gt 0 ]]; then
556 displaySeconds="true";
557 fi;
558 if $witherPrecision; then ((precision--)); fi;
559
560 ## Determine whether or not the "T" separator is needed to separate date and time elements
561 if ( $displayHours || $displayMinutes || $displaySeconds); then
562 displayDateTime="true"; else displayDateTime="false"; fi
563
564 ## Construct duration output string
565 OUTPUT="P"
566 if $displayYears; then
567 OUTPUT=$OUTPUT$fullYears"Y"; fi
568 if $displayMonths; then
569 OUTPUT=$OUTPUT$fullMonths"M"; fi
570 if $displayDays; then
571 OUTPUT=$OUTPUT$fullDays"D"; fi
572 if $displayDateTime; then
573 OUTPUT=$OUTPUT"T"; fi
574 if $displayHours; then
575 OUTPUT=$OUTPUT$fullHours"H"; fi
576 if $displayMinutes; then
577 OUTPUT=$OUTPUT$fullMinutes"M"; fi
578 if $displaySeconds; then
579 OUTPUT=$OUTPUT$fullSeconds"S"; fi
580
581 ## Output duration string to stdout
582 echo "$OUTPUT" && returnState="true";
583
584 #===Determine function return code===
585 if [ "$returnState" = "true" ]; then
586 return 0;
587 elif [ "$returnState" = "error_input" ]; then
588 yell "ERROR:input";
589 return 1;
590 else
591 yell "ERROR:Unknown";
592 return 2;
593 fi
594
595} # Get duration (ex: PT10M4S )
596displayMissing() {
597 # Desc: Displays missing apps, files, and dirs
598 # Usage: displayMissing
599 # Input: associative arrays: appRollCall, fileRollCall, dirRollCall
600 # Output: stderr messages
601 #==BEGIN Display errors==
602 #===BEGIN Display Missing Apps===
603 missingApps="Missing apps :"
604 #for key in "${!appRollCall[@]}"; do echo "DEBUG:$key => ${appRollCall[$key]}"; done
605 for key in "${!appRollCall[@]}"; do
606 value="${appRollCall[$key]}"
607 if [ "$value" = "false" ]; then
608 #echo "DEBUG:Missing apps: $key => $value";
609 missingApps="$missingApps""$key "
610 appMissing="true"
611 fi
612 done
613 if [ "$appMissing" = "true" ]; then # Only indicate if an app is missing.
614 echo "$missingApps" 1>&2;
615 fi
616 #===END Display Missing Apps===
617
618 #===BEGIN Display Missing Files===
619 missingFiles="Missing files:"
620 #for key in "${!fileRollCall[@]}"; do echo "DEBUG:$key => ${fileRollCall[$key]}"; done
621 for key in "${!fileRollCall[@]}"; do
622 value="${fileRollCall[$key]}"
623 if [ "$value" = "false" ]; then
624 #echo "DEBUG:Missing files: $key => $value";
625 missingFiles="$missingFiles""$key "
626 fileMissing="true"
627 fi
628 done
629 if [ "$fileMissing" = "true" ]; then # Only indicate if an app is missing.
630 echo "$missingFiles" 1>&2;
631 fi
632 #===END Display Missing Files===
633
634 #===BEGIN Display Missing Directories===
635 missingDirs="Missing dirs:"
636 #for key in "${!dirRollCall[@]}"; do echo "DEBUG:$key => ${dirRollCall[$key]}"; done
637 for key in "${!dirRollCall[@]}"; do
638 value="${dirRollCall[$key]}"
639 if [ "$value" = "false" ]; then
640 #echo "DEBUG:Missing dirs: $key => $value";
641 missingDirs="$missingDirs""$key "
642 dirMissing="true"
643 fi
644 done
645 if [ "$dirMissing" = "true" ]; then # Only indicate if an dir is missing.
646 echo "$missingDirs" 1>&2;
647 fi
648 #===END Display Missing Directories===
649
650 #==END Display errors==
651} # Display missing apps, files, dirs
652magicSetScriptTTL() {
653 #Desc: Sets script_TTL seconds from provided time_element string argument
654 #Usage: magicSetScriptTTL [str time_element]
655 #Input: arg1: string (Ex: SCRIPT_TTL_TE; "day" or "hour")
656 #Output: var: SCRIPT_TTL (integer seconds)
657 #Depends: timeUntilNextHour, timeUntilNextDay
658 local argTimeElement
659 argTimeElement="$1"
660 if [[ "$argTimeElement" = "day" ]]; then
661 # Set script lifespan to end at start of next day
662 if ! SCRIPT_TTL="$(timeUntilNextDay)"; then
663 if [[ "$SCRIPT_TTL" -eq 0 ]]; then
664 ((SCRIPT_TTL++)); # Add 1 because 0 would cause 'timeout' to never timeout.
665 else
666 yell "ERROR: timeUntilNextDay exit code $?"; exit 1;
667 fi;
668 fi;
669 elif [[ "$argTimeElement" = "hour" ]]; then
670 # Set script lifespan to end at start of next hour
671 if ! SCRIPT_TTL="$(timeUntilNextHour)"; then
672 if [[ "$SCRIPT_TTL" -eq 0 ]]; then
673 ((SCRIPT_TTL++)); # Add 1 because 0 would cause 'timeout' to never timeout.
674 else
675 yell "ERROR: timeUntilNextHour exit code $?"; exit 1;
676 fi;
677 fi;
678 else
679 yell "ERROR:Invalid argument for setScriptTTL function:$argTimeElement"; exit 1;
680 fi
681} # Seconds until next (day|hour).
682checkMakeTar() {
683 # Desc: Checks that a valid tar archive exists, creates one otherwise
684 # Usage: checkMakeTar [ path ]
685 # Version: 1.0.1
686 # Input: arg1: path of tar archive
687 # Output: exit code 0 : tar readable
688 # exit code 1 : tar missing; created
689 # exit code 2 : tar not readable; moved; replaced
690 # Depends: try, tar, date
691 local PATH_TAR returnFlag0 returnFlag1 returnFlag2
692 PATH_TAR="$1"
693
694 # Check if file is a valid tar archive
695 if tar --list --file="$PATH_TAR" 1>/dev/null 2>&1; then
696 ## T1: return success
697 returnFlag0="tar valid";
698 else
699 ## F1: Check if file exists
700 if [[ -f "$PATH_TAR" ]]; then
701 ### T: Rename file
702 try mv "$PATH_TAR" "$PATH_TAR""--broken--""$(date +%Y%m%dT%H%M%S)" && \
703 returnFlag1="tar moved";
704 else
705 ### F: -
706 :
707 fi
708 ## F2: Create tar archive, return 0
709 try tar --create --file="$PATH_TAR" --files-from=/dev/null && \
710 returnFlag2="tar created";
711 fi
712
713 # Determine function return code
714 if [[ "$returnFlag0" = "tar valid" ]]; then
715 return 0;
716 elif [[ "$returnFlag2" = "tar created" ]] && ! [[ "$returnFlag1" = "tar moved" ]]; then
717 return 1; # tar missing so created
718 elif [[ "$returnFlag2" = "tar created" ]] && [[ "$returnFlag1" = "tar moved" ]]; then
719 return 2; # tar not readable so moved; replaced
720 fi
721} # checks if arg1 is tar; creates one otherwise
722appendArgTar(){
723 # Desc: Writes first argument to temporary file with arguments as options, then appends file to tar
724 # Usage: appendArgTar "$(echo "Data to be written.")" [name of file to be inserted] [tar path] [temp dir] ([cmd1] [cmd2] [cmd3] [cmd4]...)
725 # Version: 1.0.3
726 # Input: arg1: data to be written
727 # arg2: file name of file to be inserted into tar
728 # arg3: tar archive path (must exist first)
729 # arg4: temporary working dir
730 # arg5+: command strings (ex: "gpsbabel -i nmea -f - -o kml -F - ")
731 # Output: file written to disk
732 # Example: decrypt multiple large files in parallel
733 # appendArgTar "$(cat /tmp/largefile1.gpg)" "largefile1" $HOME/archive.tar /tmp "gpg --decrypt" &
734 # appendArgTar "$(cat /tmp/largefile2.gpg)" "largefile2" $HOME/archive.tar /tmp "gpg --decrypt" &
735 # appendArgTar "$(cat /tmp/largefile3.gpg)" "largefile3" $HOME/archive.tar /tmp "gpg --decrypt" &
736 # Depends: bash 5
737 # Ref/Attrib: Using 'eval' to construct command strings https://askubuntu.com/a/476533
738
739 # Save function name
740 local FN="${FUNCNAME[0]}";
741 #yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
742
743 # Set file name
744 if ! [ -z "$2" ]; then FILENAME="$2"; else yell "ERROR:$FN:Not enough arguments."; exit 1; fi
745
746 # Check tar path is a file
747 if [ -f "$3" ]; then TAR_PATH="$3"; else yell "ERROR:$FN:Tar archive arg not a file."; exit 1; fi
748
749 # Check temp dir arg
750 if ! [ -z "$4" ]; then TMP_DIR="$4"; else yell "ERROR:$FN:No temporary working dir set."; exit 1; fi
751
752 # Set command strings
753 if ! [ -z "$5" ]; then CMD1="$5"; else CMD1="tee /dev/null "; fi # command string 1
754 if ! [ -z "$6" ]; then CMD2="$6"; else CMD2="tee /dev/null "; fi # command string 2
755 if ! [ -z "$7" ]; then CMD3="$7"; else CMD3="tee /dev/null "; fi # command string 3
756 if ! [ -z "$8" ]; then CMD4="$8"; else CMD4="tee /dev/null "; fi # command string 4
757
758 # Input command
759 CMD0="echo \"\$1\""
760
761 # # Debug
762 # yell "DEBUG:STATUS:$FN:CMD0:$CMD0"
763 # yell "DEBUG:STATUS:$FN:CMD1:$CMD1"
764 # yell "DEBUG:STATUS:$FN:CMD2:$CMD2"
765 # yell "DEBUG:STATUS:$FN:CMD3:$CMD3"
766 # yell "DEBUG:STATUS:$FN:CMD4:$CMD4"
767 # yell "DEBUG:STATUS:$FN:FILENAME:$FILENAME"
768 # yell "DEBUG:STATUS:$FN:TAR_PATH:$TAR_PATH"
769 # yell "DEBUG:STATUS:$FN:TMP_DIR:$TMP_DIR"
770
771 # Write to temporary working dir
772 eval "$CMD0"" | ""$CMD1"" | ""$CMD2"" | ""$CMD3"" | ""$CMD4" > "$TMP_DIR"/"$FILENAME";
773
774 # Append to tar
775 try tar --append --directory="$TMP_DIR" --file="$TAR_PATH" "$FILENAME";
776 #yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
777} # Append Bash var to file appended to Tar archive
778appendFileTar(){
779 # Desc: Processes first file and then appends to tar
780 # Usage: appendFileTar [file path] [name of file to be inserted] [tar path] [temp dir] ([cmd1] [cmd2] [cmd3] [cmd4]...)
781 # Version: 1.0.2
782 # Input: arg1: path of file to be (processed and) written
783 # arg2: name to use for file inserted into tar
784 # arg3: tar archive path (must exist first)
785 # arg4: temporary working dir
786 # arg5+: command strings (ex: "gpsbabel -i nmea -f - -o kml -F - ")
787 # Output: file written to disk
788 # Example: decrypt multiple large files in parallel
789 # appendFileTar /tmp/largefile1.gpg "largefile1" $HOME/archive.tar /tmp "gpg --decrypt" &
790 # appendFileTar /tmp/largefile2.gpg "largefile2" $HOME/archive.tar /tmp "gpg --decrypt" &
791 # appendFileTar /tmp/largefile3.gpg "largefile3" $HOME/archive.tar /tmp "gpg --decrypt" &
792 # Depends: bash 5
793
794 # Save function name
795 local FN="${FUNCNAME[0]}";
796 #yell "DEBUG:STATUS:$FN:Finished appendFileTar()."
797
798 # Set file name
799 if ! [ -z "$2" ]; then FILENAME="$2"; else yell "ERROR:$FN:Not enough arguments."; exit 1; fi
800 # Check tar path is a file
801 if [ -f "$3" ]; then TAR_PATH="$3"; else yell "ERROR:$FN:Tar archive arg not a file."; exit 1; fi
802 # Check temp dir arg
803 if ! [ -z "$4" ]; then TMP_DIR="$4"; else yell "ERROR:$FN:No temporary working dir set."; exit 1; fi
804 # Set command strings
805 if ! [ -z "$5" ]; then CMD1="$5"; else CMD1="tee /dev/null "; fi # command string 1
806 if ! [ -z "$6" ]; then CMD2="$6"; else CMD2="tee /dev/null "; fi # command string 2
807 if ! [ -z "$7" ]; then CMD3="$7"; else CMD3="tee /dev/null "; fi # command string 3
808 if ! [ -z "$8" ]; then CMD4="$8"; else CMD4="tee /dev/null "; fi # command string 4
809
810 # Input command string
811 CMD0="cat \"\$1\""
812
813 # # Debug
814 # yell "DEBUG:STATUS:$FN:CMD0:$CMD0"
815 # yell "DEBUG:STATUS:$FN:CMD1:$CMD1"
816 # yell "DEBUG:STATUS:$FN:CMD2:$CMD2"
817 # yell "DEBUG:STATUS:$FN:CMD3:$CMD3"
818 # yell "DEBUG:STATUS:$FN:CMD4:$CMD4"
819 # yell "DEBUG:STATUS:$FN:FILENAME:$FILENAME"
820 # yell "DEBUG:STATUS:$FN:TAR_PATH:$TAR_PATH"
821 # yell "DEBUG:STATUS:$FN:TMP_DIR:$TMP_DIR"
822
823 # Write to temporary working dir
824 eval "$CMD0 | $CMD1 | $CMD2 | $CMD3 | $CMD4" > "$TMP_DIR"/"$FILENAME";
825
826 # Append to tar
827 try tar --append --directory="$TMP_DIR" --file="$TAR_PATH" "$FILENAME";
828 #yell "DEBUG:STATUS:$FN:Finished appendFileTar()."
829} # Append file to Tar archive
830checkAgePubkey() {
831 # Desc: Checks if string is an age-compatible pubkey
832 # Usage: checkAgePubkey [str pubkey]
833 # Version: 0.1.2
834 # Input: arg1: string
835 # Output: return code 0: string is age-compatible pubkey
836 # return code 1: string is NOT an age-compatible pubkey
837 # age stderr (ex: there is stderr if invalid string provided)
838 # Depends: age (v0.1.0-beta2; https://github.com/FiloSottile/age/releases/tag/v1.0.0-beta2 )
839
840 argPubkey="$1";
841
842 if echo "test" | age -a -r "$argPubkey" 1>/dev/null; then
843 return 0;
844 else
845 return 1;
846 fi;
847} # Check age pubkey
848validateInput() {
849 # Desc: Validates Input
850 # Usage: validateInput [str input] [str input type]
851 # Version: 0.3.0
852 # Input: arg1: string to validate
853 # arg2: string specifying input type (ex:"ssh_pubkey")
854 # Output: return code 0: if input string matched specified string type
855 # Depends: bash 5, yell
856
857 # Save function name
858 local FN="${FUNCNAME[0]}";
859
860 # Process arguments
861 argInput="$1";
862 argType="$2";
863 if [[ $# -gt 2 ]]; then yell "ERROR:$0:$FN:Too many arguments."; exit 1; fi;
864
865 # Check for blank
866 if [[ -z "$argInput" ]]; then return 1; fi
867
868 # Define input types
869 ## ssh_pubkey
870 ### Check for alnum/dash base64 (ex: "ssh-rsa AAAAB3NzaC1yc2EAAA")
871 if [[ "$argType" = "ssh_pubkey" ]]; then
872 if [[ "$argInput" =~ ^[[:alnum:]-]*[\ ]*[[:alnum:]+/=]*$ ]]; then
873 return 0; fi; fi;
874
875 ## age_pubkey
876 ### Check for age1[:bech32:]
877 if [[ "$argType" = "age_pubkey" ]]; then
878 if [[ "$argInput" =~ ^age1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]*$ ]]; then
879 return 0; fi; fi
880
881 ## integer
882 if [[ "$argType" = "integer" ]]; then
883 if [[ "$argInput" =~ ^[[:digit:]]*$ ]]; then
884 return 0; fi; fi;
885
886 ## time element (year, month, week, day, hour, minute, second)
887 if [[ "$argType" = "time_element" ]]; then
888 if [[ "$argInput" = "year" ]] || \
889 [[ "$argInput" = "month" ]] || \
890 [[ "$argInput" = "week" ]] || \
891 [[ "$argInput" = "day" ]] || \
892 [[ "$argInput" = "hour" ]] || \
893 [[ "$argInput" = "minute" ]] || \
894 [[ "$argInput" = "second" ]]; then
895 return 0; fi; fi;
896
897 # Return error if no condition matched.
898 return 1;
899} # Validates strings
900timeEpochNS() {
901 # Desc: Get epoch nanoseconds
902 # Usage: timeEpochNS
903 # Version 0.2.2
904 # Input: arg1: 'date'-parsable timestamp string (optional)
905 # Output: Nanoseconds since 1970-01-01
906 # Depends: date 8, yell()
907 # Ref/Attrib: Force base 10 Bash arith with '10#'. https://stackoverflow.com/a/24777667
908 local TIME_CURRENT TIME_INPUT TIME_EPOCH_FLOAT TIME_EPOCH_NSFRAC
909 local TIME_EPOCH_NS
910
911 argTime="$1";
912
913 # Get Current Time
914 TIME_CURRENT="$(date --iso-8601=ns)"; # Produce `date`-parsable current timestamp with resolution of 1 nanosecond.
915
916 # Decide to parse current or supplied time
917 ## Check if time argument empty
918 if [[ -z "$argTime" ]]; then
919 ## T: Time argument empty, use current time
920 TIME_INPUT="$TIME_CURRENT";
921 else
922 ## F: Time argument exists, validate time
923 if date --date="$argTime" 1>/dev/null 2>&1; then
924 ### T: Time argument is valid; use it
925 TIME_INPUT="$argTime";
926 else
927 ### F: Time argument not valid; exit
928 yell "ERROR:Invalid time argument supplied. Exiting."; exit 1;
929 fi;
930 fi;
931 # Construct and deliver nanoseconds since 1970-01-01
932 TIME_EPOCH_FLOAT="$(date --date="$TIME_INPUT" +%s.%N)"; # Save ssss.NNNNNNNNN
933 TIME_EPOCH_INT="$(echo "$TIME_EPOCH_FLOAT" | cut -d. -f1)"; # Get ssss
934 TIME_EPOCH_NSFRAC="$(echo "$TIME_EPOCH_FLOAT" | cut -d. -f2)"; # Get NNNNNNNNN
935 TIME_EPOCH_NS="$(( (10#"$TIME_EPOCH_INT" * 10**9) + (10#"$TIME_EPOCH_NSFRAC") ))";
936 echo "$TIME_EPOCH_NS";
937} # Nanoseconds since 1970-01-01
938magicBufferSleepPID() {
939 # Desc: Compensates for lag so buffer rounds start every BUFFER_TTL seconds
940 # Input: vars: BUFFER_TTL, errResetx10e3, K_P, T_I, T_D
941 # # Input: array: errorHistory
942 # Output: vars: BUFFER_TTL_ADJ_FLOAT
943 # Re/Attrib: https://en.wikipedia.org/wiki/PID_controller#Standard_versus_parallel_(ideal)_form
944 local BUFFER_TTL_NS
945 local timeBufferStartNS timeBufferStartNSExp errNS errNSx10e3
946 local errResetx10e3 errRatex10e3 ADJ BUFFER_TTL_ADJ_NS BUFFER_TTL_ADJ_INT
947 local BUFFER_TTL_ADJ_FLOATFRAC
948 # local errorHistorySize
949
950 # ## Define errorHistorySize
951 # errorHistorySize=100;
952 ## Define BUFFER_TTL in nanoseconds
953 BUFFER_TTL_NS=$((BUFFER_TTL * 10**9)) && vbm "BUFFER_TTL_NS:$BUFFER_TTL_NS";
954
955 # Calculate Error, errNS, in nanoseconds
956 ## Get current time
957 timeBufferStartNS="$(timeEpochNS)" && vbm "timeBufferStartNS:$timeBufferStartNS";
958 ## Calculate expected time (from start time, current buffer round number, nominal BUFFER_TTL)
959 timeBufferStartNSExp="$(( (timeBufferFirstNS) + (BUFFER_TTL_NS * bufferRound) ))" && vbm "timeBufferStartNSExp:$timeBufferStartNSExp";
960 ## Calculate error (diff between timeBufferStartNSExp and timeBufferStartNS; usually negative)
961 errNS="$(( timeBufferStartNSExp - timeBufferStartNS ))" && vbm "errNS:$errNS";
962 errNSx10e3="$((errNS*10**3))" && vbm "errNSx10e3:$errNSx10e3";
963 # ## Append error to errorHistory
964 # errorHistory+=("errNS");
965 # ### Trim errorHistory array if over errorHistorySize
966 # while [[ "${#errorHistory[@]}" -gt "errorHistorySize" ]]; then do
967 # unset "errorHistory[0]"; # remove oldest entry, creating sparse array
968 # errorHistory=("${errorHistory[@]}"); # reindex sparse array
969 # vbm "STATUS:Trimmed errorHistory array. Entry count:${#errorHistory[@]}";
970 # done;
971
972 # Calculate errReset in nanoseconds^2
973 ## errReset = int(errHistory(t),wrt(delta_BUFFER_TTL))
974 ## Integrate errorHistory with respect to time
975 # for value in "${errorHistory[@]}"; do
976 # errReset=$(( errReset + ( value*BUFFER_TTL_NS ) ));
977 # done;
978 errResetx10e3="$(( ( errResetx10e3 + ( errNSx10e3 * BUFFER_TTL_NS ) )*10**3 ))" && vbm "errResetx10e3:$errResetx10e3";
979
980 # Calculate errRate in nanoseconds per 1000 nanoseconds
981 errRatex10e3="$(( ( errNSx10e3 ) / BUFFER_TTL_NS ))" && vbm "errRatex10e3:$errRatex10e3";
982
983 # Calculate PID control signal
984 ## ADJ = K_P * (errNS + errReset/T_I + errRate*T_D)
985 ADJ="$((K_P*(errNSx10e3 + (errResetx10e3/T_I) + (errRatex10e3*T_D) )/(10**3)))" && vbm "ADJ:$ADJ";
986
987 # Calculate BUFFER_TTL_ADJ_FLOAT from ADJ (ns)
988 ## Calculate BUFFER_TTL_ADJ in nanoseconds (BUFFER_TTL_ADJ_NS = BUFFER_TTL_NS + ADJ)
989 BUFFER_TTL_ADJ_NS="$((BUFFER_TTL_NS + ADJ))" && vbm "BUFFER_TTL_ADJ_NS:$BUFFER_TTL_ADJ_NS";
990 ## Calculate integer seconds
991 BUFFER_TTL_ADJ_INT="$((BUFFER_TTL_ADJ_NS/(10**9)))" && vbm "BUFFER_TTL_ADJ_INT:$BUFFER_TTL_ADJ_INT";
992 ### Catch negative integer seconds, set minimum of BUFFER_TTL/10 seconds
993 if [[ "$BUFFER_TTL_ADJ_INT" -le "$((BUFFER_TTL/10))" ]]; then
994 BUFFER_TTL_ADJ_INT="$((BUFFER_TTL/10))";
995 yell "WARNING:Buffer lag adjustment yielded negative seconds.";
996 fi;
997 ## Calculate nanosecond remainder
998 BUFFER_TTL_ADJ_FLOATFRAC="$((BUFFER_TTL_NS - (BUFFER_TTL_ADJ_INT*(10**9)) ))" && vbm "BUFFER_TTL_ADJ_FLOATFRAC:$BUFFER_TTL_ADJ_FLOATFRAC";
999 ## Form float BUFFER_TTL_ADJ_FLOAT
1000 BUFFER_TTL_ADJ_FLOAT="$BUFFER_TTL_ADJ_INT"."$BUFFER_TTL_ADJ_FLOATFRAC" && vbm "BUFFER_TTL_ADJ_FLOAT:$BUFFER_TTL_ADJ_FLOAT";
1001 vbm "STATUS:Calculated adjusted BUFFER_TTL (seconds):$BUFFER_TTL_ADJ_FLOAT";
1002 sleep 1 # Debug
1003} # Calc BUFFER_TTL_ADJ_FLOAT so buffer starts every BUFFER_TTL seconds
1004magicWriteVersion() {
1005 # Desc: Appends time-stamped VERSION to PATHOUT_TAR
1006 # Usage: magicWriteVersion
1007 # Version: 0.1.0
1008 # Input: CONTENT_VERSION, FILEOUT_VERSION, PATHOUT_TAR, DIR_TMP
1009 # Input: SCRIPT_VERSION, SCRIPT_URL, AGE_VERSION, AGE_URL, SCRIPT_HOSTNAME
1010 # Output: appends tar PATHOUT_TAR
1011 # Depends: dateTimeShort, appendArgTar
1012 local CONTENT_VERSION pubKeyIndex
1013
1014 # Set VERSION file name
1015 FILEOUT_VERSION="$(dateTimeShort)..VERSION";
1016
1017 # Gather VERSION data in CONTENT_VERSION
1018 CONTENT_VERSION="SCRIPT_VERSION=$SCRIPT_VERSION";
1019 #CONTENT_VERSION="$CONTENT_VERSION""\\n";
1020 CONTENT_VERSION="$CONTENT_VERSION""\\n""SCRIPT_NAME=$SCRIPT_NAME";
1021 CONTENT_VERSION="$CONTENT_VERSION""\\n""SCRIPT_URL=$SCRIPT_URL";
1022 CONTENT_VERSION="$CONTENT_VERSION""\\n""AGE_VERSION=$AGE_VERSION";
1023 CONTENT_VERSION="$CONTENT_VERSION""\\n""AGE_URL=$AGE_URL";
1024 CONTENT_VERSION="$CONTENT_VERSION""\\n""DATE=$(date --iso-8601=seconds)";
1025 CONTENT_VERSION="$CONTENT_VERSION""\\n""HOSTNAME=$SCRIPT_HOSTNAME";
1026 ## Add list of recipient pubkeys
1027 for pubkey in "${recPubKeysValid[@]}"; do
1028 ((pubKeyIndex++))
1029 CONTENT_VERSION="$CONTENT_VERSION""\\n""PUBKEY_$pubKeyIndex=$pubkey";
1030 done
1031 ## Process newline escapes
1032 CONTENT_VERSION="$(echo -e "$CONTENT_VERSION")"
1033
1034 # Write CONTENT_VERSION as file FILEOUT_VERSION and write-append to PATHOUT_TAR
1035 appendArgTar "$CONTENT_VERSION" "$FILEOUT_VERSION" "$PATHOUT_TAR" "$DIR_TMP";
1036
1037} # bkgpslog: write version data to PATHOUT_TAR via appendArgTar()
1038magicGatherWriteBuffer() {
1039 # Desc: bkgpslog-specific meta function for writing data to DIR_TMP then appending each file to PATHOUT_TAR
1040 # Inputs: vars: PATHOUT_TAR FILEOUT_{NMEA,GPX,KML} CMD_CONV_{NMEA,GPX,KML} CMD_{COMPRESS,ENCRYPT} DIR_TMP,
1041 # Inputs: vars: BUFFER_TTL bufferTTL_STR SCRIPT_HOSTNAME CMD_COMPRESS_SUFFIX CMD_ENCRYPT_SUFFIX
1042 # Output: file: (PATHOUT_TAR)
1043 # Depends: yell(), try(), vbm(), appendArgTar(), tar 1, sleep 8, checkMakeTar()
1044 # Depends: magicWriteVersion(), appendFileTar()
1045 local FN
1046
1047 # Debug:Get function name
1048 FN="${FUNCNAME[0]}";
1049
1050 # Create buffer file with unique name
1051 PATHOUT_BUFFER="$DIR_TMP/buffer$SECONDS";
1052 # Fill buffer
1053 timeout "$BUFFER_TTL"s gpspipe -r -o "$PATHOUT_BUFFER" ;
1054 timeBufferStart="$(dateTimeShort "$(date --date="$BUFFER_TTL seconds ago")")"; # Note start time
1055 vbm "DEBUG:STATUS:$FN:Started magicWriteBuffer().";
1056 # Determine file paths (time is start of buffer period)
1057 FILEOUT_BASENAME="$timeBufferStart""--""$bufferTTL_STR""..""$SCRIPT_HOSTNAME""_location" && vbm "STATUS:Set FILEOUT_BASENAME to:$FILEOUT_BASENAME";
1058 ## Files saved to DIR_TMP
1059 FILEOUT_NMEA="$FILEOUT_BASENAME".nmea"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_NMEA to:$FILEOUT_NMEA";
1060 FILEOUT_GPX="$FILEOUT_BASENAME".gpx"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_GPX to:$FILEOUT_GPX";
1061 FILEOUT_KML="$FILEOUT_BASENAME".kml"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_KML to:$FILEOUT_KML";
1062 PATHOUT_NMEA="$DIR_TMP"/"$FILEOUT_NMEA" && vbm "STATUS:Set PATHOUT_NMEA to:$PATHOUT_NMEA";
1063 PATHOUT_GPX="$DIR_TMP"/"$FILEOUT_GPX" && vbm "STATUS:Set PATHOUT_GPX to:$PATHOUT_GPX";
1064 PATHOUT_KML="$DIR_TMP"/"$FILEOUT_KML" && vbm "STATUS:Set PATHOUT_KML to:$PATHOUT_KML";
1065 ## Files saved to disk (DIR_OUT)
1066 ### one file per day (Ex: "20200731..hostname_location.[.gpx.gz].tar")
1067 PATHOUT_TAR="$DIR_OUT"/"$(dateShort "$(date --date="$BUFFER_TTL seconds ago")")".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
1068 vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
1069 # DEBUG: check vars
1070 vbm "STATUS:DIR_TMP :$DIR_TMP";
1071 vbm "STATUS:PATHOUT_TAR :$PATHOUT_TAR";
1072 vbm "STATUS:PATHOUT_NMEA:$PATHOUT_NMEA";
1073 vbm "STATUS:PATHOUT_GPX:$PATHOUT_GPX";
1074 vbm "STATUS:PATHOUT_KML:$PATHOUT_KML";
1075
1076
1077 # Validate PATHOUT_TAR as tar.
1078 checkMakeTar "$PATHOUT_TAR";
1079 ## Add VERSION file if checkMakeTar had to create a tar (exited 1) or replace one (exited 2)
1080 if [[ $? -eq 1 ]] || [[ $? -eq 2 ]]; then magicWriteVersion; fi
1081
1082 # Write bufferBash to PATHOUT_TAR
1083 wait; # Wait to avoid collision with older magicWriteBuffer() instances (see https://www.tldp.org/LDP/abs/html/x9644.html )
1084 appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_NMEA" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_NMEA" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write NMEA data
1085 appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_GPX" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_GPX" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write GPX file
1086 appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_KML" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_KML" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write KML file
1087
1088 # Remove secured chunks from DIR_TMP
1089 rm "$PATHOUT_BUFFER" "$PATHOUT_NMEA" "$PATHOUT_GPX" "$PATHOUT_KML";
1090 vbm "DEBUG:STATUS:$FN:Finished magicWriteBuffer().";
1091} # write buffer to disk
1092magicParseRecipientDir() {
1093 # Desc: Updates recPubKeysValid with pubkeys in dir specified by '-R' option ("recipient directory")
1094 # Inputs: vars: OPTION_RECDIR, argRecDir, OPTION_ENCRYPT
1095 # arry: recPubKeysValid
1096 # Outputs: arry: recPubKeysValid
1097 # Depends: processArguments,
1098 local recFileLine updateRecipients recipientDir
1099 declare -a candRecPubKeysValid
1100
1101 # Check that '-e' and '-R' set
1102 if [[ "$OPTION_ENCRYPT" = "true" ]] && [[ "$OPTION_RECDIR" = "true" ]]; then
1103 ### Check that argRecDir is a directory.
1104 if [[ -d "$argRecDir" ]]; then
1105 recipientDir="$argRecDir" && vbm "STATUS:Recipient watch directory detected:\"$recipientDir\"";
1106 #### Initialize variable indicating outcome of pubkey review
1107 unset updateRecipients
1108 #### Add existing recipients
1109 candRecPubKeysValid=("${recPubKeysValidStatic[@]}");
1110 #### Parse files in recipientDir
1111 for file in "$recipientDir"/*; do
1112 ##### Read first line of each file
1113 recFileLine="$(head -n1 "$file")" && vbm "STATUS:Checking if pubkey:\"$recFileLine\"";
1114 ##### check if first line is a valid pubkey
1115 if checkAgePubkey "$recFileLine" && \
1116 ( validateInput "$recFileLine" "ssh_pubkey" || validateInput "$recFileLine" "age_pubkey"); then
1117 ###### T: add candidate pubkey to candRecPubKeysValid
1118 candRecPubKeysValid+=("$recFileLine") && vbm "STATUS:RecDir pubkey is valid pubkey:\"$recFileLine\"";
1119 else
1120 ###### F: throw warning;
1121 yell "ERROR:Invalid recipient file detected. Not modifying recipient list."
1122 updateRecipients="false";
1123 fi;
1124 done
1125 #### Write updated recPubKeysValid array to recPubKeysValid if no failure detected
1126 if ! [[ "$updateRecipients" = "false" ]]; then
1127 recPubKeysValid=("${candRecPubKeysValid[@]}") && vbm "STATUS:Wrote candRecPubkeysValid to recPubKeysValid:\"${recPubKeysValid[*]}\"";
1128 fi;
1129 else
1130 yell "ERROR:$0:Recipient directory $argRecDir does not exist. Exiting."; exit 1;
1131 fi;
1132 fi;
1133 # Handle case if '-R' set but '-e' not set
1134 if [[ ! "$OPTION_ENCRYPT" = "true" ]] && [[ "$OPTION_RECDIR" = "true" ]]; then
1135 yell "ERROR: \\'-R\\' is set but \\'-e\\' is not set."; fi;
1136} # Update recPubKeysValid with argRecDir
1137magicParseRecipientArgs() {
1138 # Desc: Parses recipient arguments specified by '-r' option
1139 # Input: vars: OPTION_ENCRYPT from processArguments()
1140 # arry: argRecPubKeys from processArguments()
1141 # Output: vars: CMD_ENCRYPT, CMD_ENCRYPT_SUFFIX
1142 # arry: recPubKeysValid, recPubKeysValidStatic
1143 # Depends: checkapp(), checkAgePubkey(), validateInput(), processArguments()
1144 local recipients
1145
1146 # Check if encryption option active.
1147 if [[ "$OPTION_ENCRYPT" = "true" ]] && [[ "$OPTION_RECIPIENTS" = "true" ]]; then
1148 if checkapp age; then # Check that age is available.
1149 for pubkey in "${argRecPubKeys[@]}"; do # Validate recipient pubkey strings by forming test message
1150 vbm "DEBUG:Testing pubkey string:$pubkey";
1151 if checkAgePubkey "$pubkey" && \
1152 ( validateInput "$pubkey" "ssh_pubkey" || validateInput "$pubkey" "age_pubkey"); then
1153 #### Form age recipient string
1154 recipients="$recipients""-r '$pubkey' ";
1155 vbm "STATUS:Added pubkey for forming age recipient string:""$pubkey";
1156 vbm "DEBUG:recipients:""$recipients";
1157 #### Add validated pubkey to recPubKeysValid array
1158 recPubKeysValid+=("$pubkey") && vbm "DEBUG:recPubkeysValid:pubkey added:$pubkey";
1159 else
1160 yell "ERROR:Exit code ""$?"". Invalid recipient pubkey string. Exiting."; exit 1;
1161 fi;
1162 done
1163 vbm "DEBUG:Finished processing argRecPubKeys array";
1164 vbm "STATUS:Array of validated pubkeys:${recPubKeysValid[*]}";
1165 recPubKeysValidStatic=("${recPubKeysValid[@]}"); # Save static image of pubkeys validated by this function
1166
1167 ## Form age command string
1168 CMD_ENCRYPT="age ""$recipients " && vbm "CMD_ENCRYPT:$CMD_ENCRYPT";
1169 CMD_ENCRYPT_SUFFIX=".age" && vbm "CMD_ENCRYPT_SUFFIX:$CMD_ENCRYPT_SUFFIX";
1170 else
1171 yell "ERROR:Encryption enabled but \"age\" not found. Exiting."; exit 1;
1172 fi;
1173 else
1174 CMD_ENCRYPT="tee /dev/null " && vbm "CMD_ENCRYPT:$CMD_ENCRYPT";
1175 CMD_ENCRYPT_SUFFIX="" && vbm "CMD_ENCRYPT_SUFFIX:$CMD_ENCRYPT_SUFFIX";
1176 vbm "DEBUG:Encryption not enabled."
1177 fi;
1178 # Catch case if '-e' is set but '-r' or '-R' is not
1179 if [[ "$OPTION_ENCRYPT" = "true" ]] && [[ ! "$OPTION_RECIPIENTS" = "true" ]]; then
1180 yell "ERROR:\\'-e\\' set but no \\'-r\\' or \\'-R\\' set."; exit 1; fi;
1181 # Catch case if '-r' or '-R' set but '-e' is not
1182 if [[ ! "$OPTION_ENCRYPT" = "true" ]] && [[ "$OPTION_RECIPIENTS" = "true" ]]; then
1183 yell "ERROR:\\'-r\\' or \\'-R\\' set but \\'-e\\' is not set."; exit 1; fi;
1184} # Populate recPubKeysValid with argRecPubKeys; form encryption cmd string and filename suffix
1185magicParseCompressionArg() {
1186 # Desc: Parses compression arguments specified by '-c' option
1187 # Input: vars: OPTION_COMPRESS
1188 # Output: CMD_COMPRESS, CMD_COMPRESS_SUFFIX
1189 # Depends: checkapp(), vbm(), gzip,
1190 if [[ "$OPTION_COMPRESS" = "true" ]]; then # Check if compression option active
1191 if checkapp gzip; then # Check if gzip available
1192 CMD_COMPRESS="gzip " && vbm "CMD_COMPRESS:$CMD_COMPRESS";
1193 CMD_COMPRESS_SUFFIX=".gz" && vbm "CMD_COMPRESS_SUFFIX:$CMD_COMPRESS_SUFFIX";
1194 else
1195 yell "ERROR:Compression enabled but \"gzip\" not found. Exiting."; exit 1;
1196 fi
1197 else
1198 CMD_COMPRESS="tee /dev/null " && vbm "CMD_COMPRESS:$CMD_COMPRESS";
1199 CMD_COMPRESS_SUFFIX="" && vbm "CMD_COMPRESS_SUFFIX:$CMD_COMPRESS_SUFFIX";
1200 vbm "DEBUG:Compression not enabled.";
1201 fi
1202} # Form compression cmd string and filename suffix
1203magicInitWorkingDir() {
1204 # Desc: Determine temporary working directory from defaults or user input
1205 # Usage: magicInitWorkignDir
1206 # Input: vars: OPTION_TEMPDIR, argTempDirPriority, DIR_TMP_DEFAULT
1207 # Input: vars: SCRIPT_TIME_START
1208 # Output: vars: DIR_TMP
1209 # Depends: processArguments(), vbm(), yell()
1210 # Parse '-t' option (user-specified temporary working dir)
1211 ## Set DIR_TMP_PARENT to user-specified value if specified
1212 local DIR_TMP_PARENT
1213
1214 if [[ "$OPTION_TMPDIR" = "true" ]]; then
1215 if [[ -d "$argTempDirPriority" ]]; then
1216 DIR_TMP_PARENT="$argTempDirPriority";
1217 else
1218 yell "WARNING:Specified temporary working directory not valid:$argTempDirPriority";
1219 exit 1; # Exit since user requires a specific temp dir and it is not available.
1220 fi;
1221 else
1222 ## Set DIR_TMP_PARENT to default or fallback otherwise
1223 if [[ -d "$DIR_TMP_DEFAULT" ]]; then
1224 DIR_TMP_PARENT="$DIR_TMP_DEFAULT";
1225 elif [[ -d /tmp ]]; then
1226 yell "WARNING:$DIR_TMP_DEFAULT not available. Falling back to /tmp .";
1227 DIR_TMP_PARENT="/tmp";
1228 else
1229 yell "ERROR:No valid working directory available. Exiting.";
1230 exit 1;
1231 fi
1232 fi;
1233 ## Set DIR_TMP using DIR_TMP_PARENT and nonce (SCRIPT_TIME_START)
1234 DIR_TMP="$DIR_TMP_PARENT"/"$SCRIPT_TIME_START""..bkgpslog" && vbm "DEBUG:Set DIR_TMP to:$DIR_TMP"; # Note: removed at end of main().
1235} # Sets working dir
1236magicParseCustomTTL() {
1237 # Desc: Set user-specified TTLs for buffer and script
1238 # Input: vars: argCustomBufferTTL (integer), argCustomScriptTTL_TE (string)
1239 # Input: vars: OPTION_CUSTOM_BUFFERTTL, OPTION_CUSTOM_SCRIPTTTL
1240 # Input: vars: BUFFER_TTL (integer), SCRIPT_TTL_TE (string)
1241 # Output: BUFFER_TTL (integer), SCRIPT_TTL_TE (string)
1242 # Depends validateInput(), showUsage(), yell
1243
1244 # React to '-b, --buffer-ttl' option
1245 if [[ "$OPTION_CUSTOM_BUFFERTTL" = "true" ]]; then
1246 ## T: Check if argCustomBufferTTL is an integer
1247 if validateInput "$argCustomBufferTTL" "integer"; then
1248 ### T: argCustomBufferTTL is an integer
1249 BUFFER_TTL="$argCustomBufferTTL";
1250 else
1251 ### F: argcustomBufferTTL is not an integer
1252 yell "ERROR:Invalid integer argument for custom buffer time-to-live."; showUsage; exit 1;
1253 fi;
1254 ## F: do not change BUFFER_TTL
1255 fi;
1256
1257 # React to '-B, --script-ttl' option
1258 if [[ "$OPTION_CUSTOM_SCRIPTTTL_TE" = "true" ]]; then
1259 ## T: Check if argCustomScriptTTL is a time element (ex: "day", "hour")
1260 if validateInput "$argCustomScriptTTL" "time_element"; then
1261 ### T: argCustomScriptTTL is a time element
1262 SCRIPT_TTL_TE="$argCustomScriptTTL";
1263 else
1264 ### F: argcustomScriptTTL is not a time element
1265 yell "ERROR:Invalid time element argument for custom script time-to-live."; showUsage; exit 1;
1266 fi;
1267 ## F: do not change SCRIPT_TTL_TE
1268 fi;
1269} # Sets custom script or buffer TTL if specified
1270
1271
1272main() {
1273 # Process arguments
1274 processArguments "$@";
1275 ## Act upon arguments
1276 ### Determine working directory
1277 magicInitWorkingDir; # Sets DIR_TMP from argTempDirPriority
1278 ### Set output encryption and compression option strings
1279 #### React to "-r" ("encryption recipients") option
1280 magicParseRecipientArgs; # Updates recPubKeysValid, CMD_ENCRYPT[_SUFFIX] from argRecPubKeys
1281 #### React to "-c" ("compression") option
1282 magicParseCompressionArg; # Updates CMD_COMPRESS[_SUFFIX]
1283 #### React to "-R" ("recipient directory") option
1284 magicParseRecipientDir; # Updates recPubKeysValid
1285 #### React to custom buffer and script TTL options ("-b", "-B")
1286 magicParseCustomTTL; # Sets custom SCRIPT_TTL_TE and/or BUFFER_TTL if specified
1287
1288 # Check that critical apps and dirs are available, display missing ones.
1289 if ! checkapp gpspipe tar && ! checkdir "$DIR_OUT" "DIR_TMP"; then
1290 yell "ERROR:Critical components missing.";
1291 displayMissing; yell "Exiting."; exit 1; fi
1292
1293 # Set script lifespan (SCRIPT_TTL from SCRIPT_TTL_TE)
1294 magicSetScriptTTL "$SCRIPT_TTL_TE";
1295 ## Note: SCRIPT_TTL_TE is time element string (ex: "day") while SCRIPT_TTL is integer seconds
1296
1297 # File name substring (ISO-8601 duration from BUFFER_TTL)
1298 bufferTTL_STR="$(timeDuration "$BUFFER_TTL")";
1299
1300 # Init temp working dir
1301 try mkdir "$DIR_TMP" && vbm "DEBUG:Working dir creatd at:$DIR_TMP";
1302
1303 # Initialize 'tar' archive
1304 ## Define output tar path (note: each day gets *one* tar file (Ex: "20200731..hostname_location.[.gpx.gz].tar"))
1305 PATHOUT_TAR="$DIR_OUT"/"$(dateShort)".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
1306 vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
1307 ## Check that PATHOUT_TAR is a tar. Rename old and create empty one otherwise.
1308 checkMakeTar "$PATHOUT_TAR" && vbm "DEBUG:Confirmed or Created to be a tar:$PATHOUT_TAR";
1309 ## Append VERSION file to PATHOUT_TAR
1310 magicWriteVersion;
1311
1312 # Define GPS conversion commands
1313 CMD_CONV_NMEA="tee /dev/null " && vbm "STATUS:Set CMD_CONV_NMEA to:$CMD_CONV_NMEA"; # tee as passthrough
1314 CMD_CONV_GPX="gpsbabel -i nmea -f - -o gpx -F - " && vbm "STATUS:Set CMD_CONV_GPX to:$CMD_CONV_GPX"; # convert NMEA to GPX
1315 CMD_CONV_KML="gpsbabel -i nmea -f - -o kml -F - " && vbm "STATUS:Set CMD_CONV_KML to:$CMD_CONV_KML"; # convert NMEA to KML
1316
1317 # MAIN LOOP:Record gps data until script lifespan ends
1318 timeBufferFirstNS="$(timeEpochNS)"; bufferRound=0; BUFFER_TTL_ADJ_FLOAT="10.0";
1319 while [[ "$SECONDS" -lt "$SCRIPT_TTL" ]]; do
1320 magicParseRecipientDir;
1321 magicGatherWriteBuffer &
1322 sleep "$BUFFER_TTL_ADJ_FLOAT";
1323 ((bufferRound++));
1324 magicBufferSleepPID; # Calculates BUFFER_TTL_ADJ from BUFFER_TTL given buffer expected start time vs. actual
1325 done
1326
1327 # Cleanup
1328 ## Remove DIR_TMP
1329 try rm -r "$DIR_TMP";
1330
1331 vbm "STATUS:Main function finished.";
1332} # Main function.
1333#===END Declare local script functions===
1334#==END Define script parameters==
1335
1336
1337#==BEGIN Perform work and exit==
1338main "$@" # Run main function.
1339exit 0;
1340#==END Perform work and exit==
Environment Sensor Ninfacyzga-01