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