projects / EVA-2020-02.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
test(bkgpslog):Debug testing PID loop
[EVA-2020-02.git] / exec / bkgpslog
CommitLineData
032f4b05
SBS		 1#!/bin/bash
2
8fbca23d
SBS		 3# Desc: Records gps data until midnight
4# Author: Steven Baltakatei Sandoval; License: GPLv3+
aa2a49f1 5# Usage: bkgpslog -o [output dir]
032f4b05 6
8fbca23d 7#==BEGIN Define script parameters==
6c30388f 8## Logging Behavior parameters
3fd6a69e 9BUFFER_TTL="300"; # time between file writes
2af0d7d9 10SCRIPT_TTL_TE="day"; # (day|hour)
aa2a49f1
SBS		 11#### TZ="UTC"; export TZ; # Default time zone; overridden by '--time-zone=[str]' option
12DIR_TMP_DEFAULT="/dev/shm"; # Default parent of working directory
6c30388f 13
aa2a49f1
SBS		 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.
52f05d07 17SCRIPT_VERSION="0.4.4-alpha"; # Define version of script.
ff22a93f
SBS		 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.
8fbca23d
SBS		 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
320ac29c 26declare -a argRecPubKeys # for processArguments function
52f05d07 27# declare -a errorHistory # for correcting buffer lag
8fbca23d 28
cfc25c90
SBS		 29## Initialize variables
30OPTION_VERBOSE=""; OPTION_ENCRYPT=""; OPTION_COMPRESS=""; OPTION_TMPDIR="";
52f05d07
SBS		 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
cfc25c90 36
8fbca23d
SBS		 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"
0b3dde05 51 if command -v "$arg" 1>/dev/null 2>&1; then # Check if arg is a valid command
8fbca23d
SBS		 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
bcf09dcc 119 elif [ "$arg" = "" ]; then
8fbca23d 120 dirRollCall["$arg"]="false"; returnState="false";
bcf09dcc
SBS		 121 else
122 returnState="false";
8fbca23d
SBS		 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
032f4b05 138
c609b9c8
SBS		 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
032f4b05
SBS		 145echoerr() {
146 echo "$@" 1>&2; # Define stderr echo function.
147} # Define stderr message function.
148showUsage() {
149 echoerr "USAGE:"
94e094d1 150 echoerr " bkgpslog [ options ]"
032f4b05
SBS		 151 echoerr
152 echoerr "OPTIONS:"
153 echoerr " -h, --help"
154 echoerr " Display help information."
032f4b05
SBS		 155 echoerr " --version"
156 echoerr " Display script version."
032f4b05
SBS		 157 echoerr " -v, --verbose"
158 echoerr " Display debugging info."
17d49005
SBS		 159 echoerr " -e, --encrypt"
160 echoerr " Encrypt output."
2af0d7d9 161 echoerr " -r, --recipient [ string pubkey ]"
f7f33d33 162 echoerr " Specify recipient. May be age or ssh pubkey."
2af0d7d9 163 echoerr " May be specified multiple times for multiple pubkeys."
f7f33d33 164 echoerr " See https://github.com/FiloSottile/age"
2af0d7d9 165 echoerr " -o, --output [ path dir ]"
032f4b05 166 echoerr " Specify output directory to save logs."
408a342b
SBS		 167 echoerr " -c, --compress"
168 echoerr " Compress output with gzip (before encryption if enabled)."
f7f33d33
SBS		 169 echoerr " -z, --time-zone"
170 echoerr " Specify time zone. (ex: \"America/New_York\")"
2af0d7d9 171 echoerr " -t, --temp-dir [path dir]"
f7f33d33
SBS		 172 echoerr " Specify parent directory for temporary working directory."
173 echoerr " Default: \"/dev/shm\""
2af0d7d9 174 echoerr " -R, --recipient-dir [path dir]"
320ac29c 175 echoerr " Specify directory containing files whose first lines are"
2af0d7d9
SBS		 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\")"
f7f33d33 181 echoerr
17d49005 182 echoerr "EXAMPLE: (bash script lines)"
320ac29c
SBS		 183 echoerr "/bin/bash bkgpslog -v -e -c \\"
184 echoerr "-z \"UTC\" -t \"/dev/shm\" \\"
17d49005
SBS		 185 echoerr "-r age1mrmfnwhtlprn4jquex0ukmwcm7y2nxlphuzgsgv8ew2k9mewy3rs8u7su5 \\"
186 echoerr "-r age1ala848kqrvxc88rzaauc6vc5v0fqrvef9dxyk79m0vjea3hagclswu0lgq \\"
187 echoerr "-o ~/Sync/Location"
032f4b05
SBS		 188} # Display information on how to use this script.
189showVersion() {
190 echoerr "$SCRIPT_VERSION"
191} # Display script version.
192vbm() {
0b3dde05
SBS		 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.
032f4b05 209 fi
0b3dde05
SBS		 210
211 # End function
212 return 0; # Function finished.
032f4b05
SBS		 213} # Verbose message display function.
214processArguments() {
215 while [ ! $# -eq 0 ]; do # While number of arguments ($#) is not (!) equal to (-eq) zero (0).
d6896d3b
SBS		 216 #echoerr "DEBUG:Starting processArguments while loop."
217 #echoerr "DEBUG:Provided arguments are:""$*"
032f4b05 218 case "$1" in
c1bbf9f7 219 -h | --help) showUsage; exit 1;; # Display usage.
032f4b05 220 --version) showVersion; exit 1;; # Show version
c1bbf9f7 221 -v | --verbose) OPTION_VERBOSE="true"; vbm "DEBUG:Verbose mode enabled.";; # Enable verbose mode.
6c30388f 222 -o | --output) if [ -d "$2" ]; then DIR_OUT="$2"; vbm "DEBUG:DIR_OUT:$DIR_OUT"; shift; fi ;; # Define output directory.
6a2cd888
SBS		 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
c9c573da 227 -t | --temp-dir) OPTION_TMPDIR="true" && argTempDirPriority="$2"; shift;; # Set time zone
6a2cd888 228 -R | --recipient-dir) OPTION_RECIPIENTS="true"; OPTION_RECDIR="true" && argRecDir="$2"; shift;; # Add recipient watch dir
2af0d7d9
SBS		 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")
b0da06ca 231 *) echoerr "ERROR: Unrecognized argument: $1"; echoerr "STATUS:All arguments:$*"; exit 1;; # Handle unrecognized options.
032f4b05
SBS		 232 esac
233 shift
234 done
235} # Argument Processing
6c30388f
SBS		 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
c2aaff78
SBS		 275timeUntilNextDay(){
276 # Desc: Report seconds until next day.
3395ae22 277 # Version: 1.0.0
c2aaff78 278 # Output: stdout: integer seconds until next day
8fbca23d 279 # Output: exit code 0 if stdout > 0; 1 if stdout = 0; 2 if stdout < 0
c2aaff78
SBS		 280 # Usage: timeUntilNextDay
281 # Usage: if ! myTTL="$(timeUntilNextDay)"; then yell "ERROR in if statement"; exit 1; fi
3395ae22
SBS		 282 # Depends: date 8, echo 8, yell, try
283
c2aaff78 284 local returnState TIME_CURRENT TIME_NEXT_DAY SECONDS_UNTIL_NEXT_DAY
3395ae22 285
8fbca23d 286 TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
c2aaff78
SBS		 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
3395ae22 292 returnState="warning_zero";
c2aaff78
SBS		 293 yell "WARNING:Reported time until next day exactly zero.";
294 elif [[ "$SECONDS_UNTIL_NEXT_DAY" -lt 0 ]]; then
3395ae22 295 returnState="warning_negative";
c2aaff78
SBS		 296 yell "WARNING:Reported time until next day is negative.";
297 fi
298
299 try echo "$SECONDS_UNTIL_NEXT_DAY"; # Report
300
3395ae22 301 # Determine function return code
c2aaff78
SBS		 302 if [[ "$returnState" = "true" ]]; then
303 return 0;
3395ae22 304 elif [[ "$returnState" = "warning_zero" ]]; then
c2aaff78 305 return 1;
3395ae22 306 elif [[ "$returnState" = "warning_negative" ]]; then
c2aaff78
SBS		 307 return 2;
308 fi
309} # Report seconds until next day
310timeUntilNextHour(){
311 # Desc: Report seconds until next hour
3395ae22 312 # Version 1.0.0
c2aaff78
SBS		 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
3395ae22 317
c2aaff78
SBS		 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
8fbca23d 323 returnState="true";
c2aaff78 324 elif [[ "$SECONDS_UNTIL_NEXT_HOUR" -eq 0 ]]; then
3395ae22 325 returnState="warning_zero";
c2aaff78
SBS		 326 yell "WARNING:Reported time until next hour exactly zero.";
327 elif [[ "$SECONDS_UNTIL_NEXT_HOUR" -lt 0 ]]; then
3395ae22 328 returnState="warning_negative";
c2aaff78 329 yell "WARNING:Reported time until next hour is negative.";
8fbca23d 330 fi
032f4b05 331
c2aaff78 332 try echo "$SECONDS_UNTIL_NEXT_HOUR"; # Report
8fbca23d 333
3395ae22 334 # Determine function return code
8fbca23d
SBS		 335 if [[ "$returnState" = "true" ]]; then
336 return 0;
3395ae22 337 elif [[ "$returnState" = "warning_zero" ]]; then
8fbca23d 338 return 1;
3395ae22 339 elif [[ "$returnState" = "warning_negative" ]]; then
8fbca23d
SBS		 340 return 2;
341 fi
c2aaff78 342} # Report seconds until next hour
8fbca23d
SBS		 343dateTimeShort(){
344 # Desc: Timestamp without separators (YYYYmmddTHHMMSS+zzzz)
e47e8048
SBS		 345 # Usage: dateTimeShort ([str date])
346 # Version 1.1.0
347 # Input: arg1: 'date'-parsable timestamp string (optional)
8fbca23d 348 # Output: stdout: timestamp (ISO-8601, no separators)
e47e8048 349 # Depends: yell
c2aaff78 350 local TIME_CURRENT TIME_CURRENT_SHORT
e47e8048
SBS		 351
352 argTime="$1";
353 # Get Current Time
8fbca23d 354 TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
e47e8048
SBS		 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)";
8fbca23d 372 echo "$TIME_CURRENT_SHORT";
6c30388f
SBS		 373} # Get YYYYmmddTHHMMSS±zzzz
374dateShort(){
375 # Desc: Date without separators (YYYYmmdd)
e47e8048
SBS		 376 # Usage: dateShort ([str date])
377 # Version: 1.1.0
378 # Input: arg1: 'date'-parsable timestamp string (optional)
6c30388f 379 # Output: stdout: date (ISO-8601, no separators)
e47e8048 380 # Depends: yell
6c30388f 381 local TIME_CURRENT DATE_CURRENT_SHORT
e47e8048
SBS		 382
383 argTime="$1";
384 # Get Current Time
6c30388f 385 TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
e47e8048
SBS		 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.
6c30388f
SBS		 403 echo "$DATE_CURRENT_SHORT";
404} # Get YYYYmmdd
405timeDuration(){
a7b4a273 406 # Desc: Given seconds, output ISO-8601 duration string
6c30388f
SBS		 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)
a7b4a273
SBS		 409 # Usage: timeDuration [1:seconds] ([2:precision])
410 # Version: 1.0.3
6c30388f
SBS		 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")
a7b4a273
SBS		 414 # exit code 0: success
415 # exit code 1: error_input
416 # exit code 2: error_unknown
6c30388f 417 # Example: 'timeDuration 111111 3' yields 'P1DT6H51M'
3395ae22 418 # Depends: date 8 (gnucoreutils), yell,
a7b4a273 419 local returnState argSeconds argPrecision remainder precision witherPrecision
3395ae22
SBS		 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
a7b4a273
SBS		 424 argSeconds="$1"; # read arg1 (seconds)
425 argPrecision="$2"; # read arg2 (precision)
6c30388f 426 precision=2; # set default precision
6c30388f
SBS		 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.";
a7b4a273 431 returnState="error_input"; fi
6c30388f 432
a7b4a273 433 # Check that argSeconds provided
6c30388f 434 if [[ $# -ge 1 ]]; then
a7b4a273
SBS		 435 ## Check that argSeconds is a positive integer
436 if [[ "$argSeconds" =~ ^[[:digit:]]+$ ]]; then
3395ae22 437 :
6c30388f 438 else
a7b4a273
SBS		 439 yell "ERROR:argSeconds not a digit.";
440 returnState="error_input";
6c30388f
SBS		 441 fi
442 else
443 yell "ERROR:No argument provided. Exiting.";
444 exit 1;
445 fi
446
a7b4a273 447 # Consider whether argPrecision was provided
6c30388f 448 if [[ $# -eq 2 ]]; then
a7b4a273
SBS		 449 # Check that argPrecision is a positive integer
450 if [[ "$argPrecision" =~ ^[[:digit:]]+$ ]] && [[ "$argPrecision" -gt 0 ]]; then
451 precision="$argPrecision";
6c30388f 452 else
a7b4a273
SBS		 453 yell "ERROR:argPrecision not a positive integer. (is $argPrecision ). Leaving early.";
454 returnState="error_input";
6c30388f
SBS		 455 fi;
456 else
3395ae22 457 :
6c30388f
SBS		 458 fi;
459
a7b4a273 460 remainder="$argSeconds" ; # seconds
6c30388f
SBS		 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
6c30388f
SBS		 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
a7b4a273 582 echo "$OUTPUT" && returnState="true";
6c30388f
SBS		 583
584 #===Determine function return code===
585 if [ "$returnState" = "true" ]; then
586 return 0;
a7b4a273
SBS		 587 elif [ "$returnState" = "error_input" ]; then
588 yell "ERROR:input";
6c30388f 589 return 1;
a7b4a273
SBS		 590 else
591 yell "ERROR:Unknown";
592 return 2;
6c30388f
SBS		 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
2af0d7d9
SBS		 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
6c30388f 661 # Set script lifespan to end at start of next day
2af0d7d9
SBS		 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.
6c30388f
SBS		 665 else
666 yell "ERROR: timeUntilNextDay exit code $?"; exit 1;
667 fi;
668 fi;
2af0d7d9 669 elif [[ "$argTimeElement" = "hour" ]]; then
6c30388f 670 # Set script lifespan to end at start of next hour
2af0d7d9
SBS		 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.
6c30388f
SBS		 674 else
675 yell "ERROR: timeUntilNextHour exit code $?"; exit 1;
676 fi;
677 fi;
678 else
2af0d7d9 679 yell "ERROR:Invalid argument for setScriptTTL function:$argTimeElement"; exit 1;
6c30388f
SBS		 680 fi
681} # Seconds until next (day|hour).
f6fb18bd
SBS		 682checkMakeTar() {
683 # Desc: Checks that a valid tar archive exists, creates one otherwise
684 # Usage: checkMakeTar [ path ]
2fc10824 685 # Version: 1.0.1
f6fb18bd 686 # Input: arg1: path of tar archive
2fc10824
SBS		 687 # Output: exit code 0 : tar readable
688 # exit code 1 : tar missing; created
689 # exit code 2 : tar not readable; moved; replaced
f6fb18bd 690 # Depends: try, tar, date
2fc10824
SBS		 691 local PATH_TAR returnFlag0 returnFlag1 returnFlag2
692 PATH_TAR="$1"
f6fb18bd
SBS		 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
2fc10824 697 returnFlag0="tar valid";
f6fb18bd
SBS		 698 else
699 ## F1: Check if file exists
700 if [[ -f "$PATH_TAR" ]]; then
701 ### T: Rename file
2fc10824
SBS		 702 try mv "$PATH_TAR" "$PATH_TAR""--broken--""$(date +%Y%m%dT%H%M%S)" && \
703 returnFlag1="tar moved";
f6fb18bd
SBS		 704 else
705 ### F: -
706 :
707 fi
708 ## F2: Create tar archive, return 0
2fc10824
SBS		 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
f6fb18bd 715 return 0;
2fc10824
SBS		 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
f6fb18bd
SBS		 720 fi
721} # checks if arg1 is tar; creates one otherwise
66af6225
SBS		 722appendArgTar(){
723 # Desc: Writes first argument to temporary file with arguments as options, then appends file to tar
e47e8048 724 # Usage: appendArgTar "$(echo "Data to be written.")" [name of file to be inserted] [tar path] [temp dir] ([cmd1] [cmd2] [cmd3] [cmd4]...)
f665ce95 725 # Version: 1.0.3
66af6225
SBS		 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" &
66af6225 736 # Depends: bash 5
f665ce95 737 # Ref/Attrib: Using 'eval' to construct command strings https://askubuntu.com/a/476533
66af6225 738
d9fe1eba 739 # Save function name
d7138c7f
SBS		 740 local FN="${FUNCNAME[0]}";
741 #yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
d9fe1eba 742
66af6225 743 # Set file name
d9fe1eba 744 if ! [ -z "$2" ]; then FILENAME="$2"; else yell "ERROR:$FN:Not enough arguments."; exit 1; fi
66af6225
SBS		 745
746 # Check tar path is a file
d9fe1eba 747 if [ -f "$3" ]; then TAR_PATH="$3"; else yell "ERROR:$FN:Tar archive arg not a file."; exit 1; fi
66af6225
SBS		 748
749 # Check temp dir arg
d9fe1eba 750 if ! [ -z "$4" ]; then TMP_DIR="$4"; else yell "ERROR:$FN:No temporary working dir set."; exit 1; fi
66af6225
SBS		 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
f665ce95
SBS		 758 # Input command
759 CMD0="echo \"\$1\""
760
d7138c7f 761 # # Debug
f665ce95 762 # yell "DEBUG:STATUS:$FN:CMD0:$CMD0"
d7138c7f
SBS		 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
66af6225 771 # Write to temporary working dir
f665ce95 772 eval "$CMD0"" | ""$CMD1"" | ""$CMD2"" | ""$CMD3"" | ""$CMD4" > "$TMP_DIR"/"$FILENAME";
66af6225
SBS		 773
774 # Append to tar
775 try tar --append --directory="$TMP_DIR" --file="$TAR_PATH" "$FILENAME";
d7138c7f 776 #yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
66af6225 777} # Append Bash var to file appended to Tar archive
e47e8048
SBS		 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]...)
f665ce95 781 # Version: 1.0.2
e47e8048
SBS		 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
f665ce95
SBS		 809
810 # Input command string
811 CMD0="cat \"\$1\""
812
e47e8048 813 # # Debug
f665ce95 814 # yell "DEBUG:STATUS:$FN:CMD0:$CMD0"
e47e8048
SBS		 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
f665ce95 824 eval "$CMD0 | $CMD1 | $CMD2 | $CMD3 | $CMD4" > "$TMP_DIR"/"$FILENAME";
e47e8048
SBS		 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
320ac29c
SBS		 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
d6ba4173
SBS		 848validateInput() {
849 # Desc: Validates Input
850 # Usage: validateInput [str input] [str input type]
2af0d7d9 851 # Version: 0.3.0
d6ba4173
SBS		 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
2af0d7d9 873 return 0; fi; fi;
d6ba4173
SBS		 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
2af0d7d9
SBS		 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
d6ba4173
SBS		 897 # Return error if no condition matched.
898 return 1;
899} # Validates strings
52f05d07
SBS		 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
d59a052d 953 BUFFER_TTL_NS=$((BUFFER_TTL * 10**9)) && vbm "BUFFER_TTL_NS:$BUFFER_TTL_NS";
52f05d07
SBS		 954
955 # Calculate Error, errNS, in nanoseconds
956 ## Get current time
d59a052d 957 timeBufferStartNS="$(timeEpochNS)" && vbm "timeBufferStartNS:$timeBufferStartNS";
52f05d07 958 ## Calculate expected time (from start time, current buffer round number, nominal BUFFER_TTL)
d59a052d 959 timeBufferStartNSExp="$(( (timeBufferFirstNS) + (BUFFER_TTL_NS * bufferRound) ))" && vbm "timeBufferStartNSExp:$timeBufferStartNSExp";
52f05d07 960 ## Calculate error (diff between timeBufferStartNSExp and timeBufferStartNS; usually negative)
d59a052d
SBS		 961 errNS="$(( timeBufferStartNSExp - timeBufferStartNS ))" && vbm "errNS:$errNS";
962 errNSx10e3="$((errNS*10**3))" && vbm "errNSx10e3:$errNSx10e3";
52f05d07
SBS		 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;
d59a052d 978 errResetx10e3="$(( ( errResetx10e3 + ( errNS * BUFFER_TTL_NS ) )*10**3 ))" && vbm "errResetx10e3:$errResetx10e3";
52f05d07
SBS		 979
980 # Calculate errRate in nanoseconds per 1000 nanoseconds
d59a052d 981 errRatex10e3="$(( ( errNSx10e3 ) / BUFFER_TTL_NS ))" && vbm "errRatex10e3:$errRatex10e3";
52f05d07
SBS		 982
983 # Calculate PID control signal
984 ## ADJ = K_P * (errNS + errReset/T_I + errRate*T_D)
d59a052d 985 ADJ="$((K_P*(errNSx10e3 + (errResetx10e3/T_I) + (errRatex10e3*T_D) )/10**3))" && vbm "ADJ:$ADJ";
52f05d07
SBS		 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)
d59a052d 989 BUFFER_TTL_ADJ_NS="$((BUFFER_TTL_NS + ADJ))" && vbm "BUFFER_TTL_ADJ_NS:$BUFFER_TTL_ADJ_NS";
52f05d07 990 ## Calculate integer seconds
d59a052d 991 BUFFER_TTL_ADJ_INT="$((BUFFER_TTL_ADJ_NS/(10**9)))" && vbm "BUFFER_TTL_ADJ_INT:$BUFFER_TTL_ADJ_INT";
52f05d07 992 ## Calculate nanosecond remainder
d59a052d 993 BUFFER_TTL_ADJ_FLOATFRAC="$((BUFFER_TTL_NS - (BUFFER_TTL_ADJ_INT*(10**9)) ))" && vbm "BUFFER_TTL_ADJ_FLOATFRAC:$BUFFER_TTL_ADJ_FLOATFRAC";
52f05d07 994 ## Form float BUFFER_TTL_ADJ_FLOAT
d59a052d 995 BUFFER_TTL_ADJ_FLOAT="$BUFFER_TTL_ADJ_INT"."$BUFFER_TTL_ADJ_FLOATFRAC" && vbm "BUFFER_TTL_ADJ_FLOAT:$BUFFER_TTL_ADJ_FLOAT";
52f05d07 996 vbm "STATUS:Calculated adjusted BUFFER_TTL (seconds):$BUFFER_TTL_ADJ_FLOAT";
d59a052d 997 sleep 1 # Debug
52f05d07 998} # Calc BUFFER_TTL_ADJ_FLOAT so buffer starts every BUFFER_TTL seconds
3395ae22
SBS		 999magicWriteVersion() {
1000 # Desc: Appends time-stamped VERSION to PATHOUT_TAR
1001 # Usage: magicWriteVersion
ff22a93f 1002 # Version: 0.1.0
3395ae22 1003 # Input: CONTENT_VERSION, FILEOUT_VERSION, PATHOUT_TAR, DIR_TMP
ff22a93f
SBS		 1004 # Input: SCRIPT_VERSION, SCRIPT_URL, AGE_VERSION, AGE_URL, SCRIPT_HOSTNAME
1005 # Output: appends tar PATHOUT_TAR
3395ae22 1006 # Depends: dateTimeShort, appendArgTar
ff22a93f 1007 local CONTENT_VERSION pubKeyIndex
3395ae22 1008
ff22a93f 1009 # Set VERSION file name
3395ae22 1010 FILEOUT_VERSION="$(dateTimeShort)..VERSION";
ff22a93f
SBS		 1011
1012 # Gather VERSION data in CONTENT_VERSION
1013 CONTENT_VERSION="SCRIPT_VERSION=$SCRIPT_VERSION";
aa2d7921
SBS		 1014 #CONTENT_VERSION="$CONTENT_VERSION""\\n";
1015 CONTENT_VERSION="$CONTENT_VERSION""\\n""SCRIPT_NAME=$SCRIPT_NAME";
1016 CONTENT_VERSION="$CONTENT_VERSION""\\n""SCRIPT_URL=$SCRIPT_URL";
1017 CONTENT_VERSION="$CONTENT_VERSION""\\n""AGE_VERSION=$AGE_VERSION";
1018 CONTENT_VERSION="$CONTENT_VERSION""\\n""AGE_URL=$AGE_URL";
1019 CONTENT_VERSION="$CONTENT_VERSION""\\n""DATE=$(date --iso-8601=seconds)";
1020 CONTENT_VERSION="$CONTENT_VERSION""\\n""HOSTNAME=$SCRIPT_HOSTNAME";
ff22a93f
SBS		 1021 ## Add list of recipient pubkeys
1022 for pubkey in "${recPubKeysValid[@]}"; do
1023 ((pubKeyIndex++))
aa2d7921 1024 CONTENT_VERSION="$CONTENT_VERSION""\\n""PUBKEY_$pubKeyIndex=$pubkey";
ff22a93f
SBS		 1025 done
1026 ## Process newline escapes
4c0c5850
SBS		 1027 CONTENT_VERSION="$(echo -e "$CONTENT_VERSION")"
1028
ff22a93f 1029 # Write CONTENT_VERSION as file FILEOUT_VERSION and write-append to PATHOUT_TAR
3395ae22 1030 appendArgTar "$CONTENT_VERSION" "$FILEOUT_VERSION" "$PATHOUT_TAR" "$DIR_TMP";
ff22a93f 1031
3395ae22 1032} # bkgpslog: write version data to PATHOUT_TAR via appendArgTar()
811f50f2 1033magicGatherWriteBuffer() {
66af6225 1034 # Desc: bkgpslog-specific meta function for writing data to DIR_TMP then appending each file to PATHOUT_TAR
52f05d07
SBS		 1035 # Inputs: vars: PATHOUT_TAR FILEOUT_{NMEA,GPX,KML} CMD_CONV_{NMEA,GPX,KML} CMD_{COMPRESS,ENCRYPT} DIR_TMP,
1036 # Inputs: vars: BUFFER_TTL bufferTTL_STR SCRIPT_HOSTNAME CMD_COMPRESS_SUFFIX CMD_ENCRYPT_SUFFIX
1037 # Output: file: (PATHOUT_TAR)
1038 # Depends: yell(), try(), vbm(), appendArgTar(), tar 1, sleep 8, checkMakeTar()
1039 # Depends: magicWriteVersion(), appendFileTar()
1040 local FN
1041
1042 # Debug:Get function name
1043 FN="${FUNCNAME[0]}";
1044
811f50f2
SBS		 1045 # Create buffer file with unique name
1046 PATHOUT_BUFFER="$DIR_TMP/buffer$SECONDS";
1047 # Fill buffer
1048 timeout "$BUFFER_TTL"s gpspipe -r -o "$PATHOUT_BUFFER" ;
11f61f1a 1049 timeBufferStart="$(dateTimeShort "$(date --date="$BUFFER_TTL seconds ago")")"; # Note start time
e47e8048
SBS		 1050 vbm "DEBUG:STATUS:$FN:Started magicWriteBuffer().";
1051 # Determine file paths (time is start of buffer period)
1052 FILEOUT_BASENAME="$timeBufferStart""--""$bufferTTL_STR""..""$SCRIPT_HOSTNAME""_location" && vbm "STATUS:Set FILEOUT_BASENAME to:$FILEOUT_BASENAME";
1053 ## Files saved to DIR_TMP
1054 FILEOUT_NMEA="$FILEOUT_BASENAME".nmea"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_NMEA to:$FILEOUT_NMEA";
1055 FILEOUT_GPX="$FILEOUT_BASENAME".gpx"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_GPX to:$FILEOUT_GPX";
1056 FILEOUT_KML="$FILEOUT_BASENAME".kml"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_KML to:$FILEOUT_KML";
1057 PATHOUT_NMEA="$DIR_TMP"/"$FILEOUT_NMEA" && vbm "STATUS:Set PATHOUT_NMEA to:$PATHOUT_NMEA";
1058 PATHOUT_GPX="$DIR_TMP"/"$FILEOUT_GPX" && vbm "STATUS:Set PATHOUT_GPX to:$PATHOUT_GPX";
1059 PATHOUT_KML="$DIR_TMP"/"$FILEOUT_KML" && vbm "STATUS:Set PATHOUT_KML to:$PATHOUT_KML";
1060 ## Files saved to disk (DIR_OUT)
1061 ### one file per day (Ex: "20200731..hostname_location.[.gpx.gz].tar")
1062 PATHOUT_TAR="$DIR_OUT"/"$(dateShort "$(date --date="$BUFFER_TTL seconds ago")")".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
1063 vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
1064 # DEBUG: check vars
1065 vbm "STATUS:DIR_TMP :$DIR_TMP";
1066 vbm "STATUS:PATHOUT_TAR :$PATHOUT_TAR";
1067 vbm "STATUS:PATHOUT_NMEA:$PATHOUT_NMEA";
1068 vbm "STATUS:PATHOUT_GPX:$PATHOUT_GPX";
1069 vbm "STATUS:PATHOUT_KML:$PATHOUT_KML";
1070
1071
3395ae22
SBS		 1072 # Validate PATHOUT_TAR as tar.
1073 checkMakeTar "$PATHOUT_TAR";
1074 ## Add VERSION file if checkMakeTar had to create a tar (exited 1) or replace one (exited 2)
1075 if [[ $? -eq 1 ]] || [[ $? -eq 2 ]]; then magicWriteVersion; fi
f6fb18bd
SBS		 1076
1077 # Write bufferBash to PATHOUT_TAR
52f05d07 1078 wait; # Wait to avoid collision with older magicWriteBuffer() instances (see https://www.tldp.org/LDP/abs/html/x9644.html )
e47e8048
SBS		 1079 appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_NMEA" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_NMEA" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write NMEA data
1080 appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_GPX" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_GPX" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write GPX file
1081 appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_KML" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_KML" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write KML file
1082
e0452100 1083 # Remove secured chunks from DIR_TMP
e47e8048
SBS		 1084 rm "$PATHOUT_BUFFER" "$PATHOUT_NMEA" "$PATHOUT_GPX" "$PATHOUT_KML";
1085 vbm "DEBUG:STATUS:$FN:Finished magicWriteBuffer().";
1086} # write buffer to disk
320ac29c
SBS		 1087magicParseRecipientDir() {
1088 # Desc: Updates recPubKeysValid with pubkeys in dir specified by '-R' option ("recipient directory")
2038018c 1089 # Inputs: vars: OPTION_RECDIR, argRecDir, OPTION_ENCRYPT
50324e94
SBS		 1090 # arry: recPubKeysValid
1091 # Outputs: arry: recPubKeysValid
320ac29c
SBS		 1092 # Depends: processArguments,
1093 local recFileLine updateRecipients recipientDir
1094 declare -a candRecPubKeysValid
50324e94
SBS		 1095
1096 # Check that '-e' and '-R' set
2038018c 1097 if [[ "$OPTION_ENCRYPT" = "true" ]] && [[ "$OPTION_RECDIR" = "true" ]]; then
320ac29c
SBS		 1098 ### Check that argRecDir is a directory.
1099 if [[ -d "$argRecDir" ]]; then
fd5ef60e 1100 recipientDir="$argRecDir" && vbm "STATUS:Recipient watch directory detected:\"$recipientDir\"";
320ac29c
SBS		 1101 #### Initialize variable indicating outcome of pubkey review
1102 unset updateRecipients
1103 #### Add existing recipients
6010b172 1104 candRecPubKeysValid=("${recPubKeysValidStatic[@]}");
320ac29c
SBS		 1105 #### Parse files in recipientDir
1106 for file in "$recipientDir"/*; do
1107 ##### Read first line of each file
fd5ef60e 1108 recFileLine="$(head -n1 "$file")" && vbm "STATUS:Checking if pubkey:\"$recFileLine\"";
320ac29c
SBS		 1109 ##### check if first line is a valid pubkey
1110 if checkAgePubkey "$recFileLine" && \
1111 ( validateInput "$recFileLine" "ssh_pubkey" || validateInput "$recFileLine" "age_pubkey"); then
1112 ###### T: add candidate pubkey to candRecPubKeysValid
fd5ef60e 1113 candRecPubKeysValid+=("$recFileLine") && vbm "STATUS:RecDir pubkey is valid pubkey:\"$recFileLine\"";
320ac29c
SBS		 1114 else
1115 ###### F: throw warning;
1116 yell "ERROR:Invalid recipient file detected. Not modifying recipient list."
1117 updateRecipients="false";
1118 fi;
1119 done
1120 #### Write updated recPubKeysValid array to recPubKeysValid if no failure detected
2af0d7d9 1121 if ! [[ "$updateRecipients" = "false" ]]; then
52f05d07 1122 recPubKeysValid=("${candRecPubKeysValid[@]}") && vbm "STATUS:Wrote candRecPubkeysValid to recPubKeysValid:\"${recPubKeysValid[*]}\"";
320ac29c 1123 fi;
cfc25c90 1124 else
320ac29c
SBS		 1125 yell "ERROR:$0:Recipient directory $argRecDir does not exist. Exiting."; exit 1;
1126 fi;
1127 fi;
50324e94 1128 # Handle case if '-R' set but '-e' not set
2038018c 1129 if [[ ! "$OPTION_ENCRYPT" = "true" ]] && [[ "$OPTION_RECDIR" = "true" ]]; then
2af0d7d9 1130 yell "ERROR: \\'-R\\' is set but \\'-e\\' is not set."; fi;
320ac29c
SBS		 1131} # Update recPubKeysValid with argRecDir
1132magicParseRecipientArgs() {
1133 # Desc: Parses recipient arguments specified by '-r' option
1134 # Input: vars: OPTION_ENCRYPT from processArguments()
1135 # arry: argRecPubKeys from processArguments()
1136 # Output: vars: CMD_ENCRYPT, CMD_ENCRYPT_SUFFIX
6010b172 1137 # arry: recPubKeysValid, recPubKeysValidStatic
320ac29c
SBS		 1138 # Depends: checkapp(), checkAgePubkey(), validateInput(), processArguments()
1139 local recipients
cfc25c90 1140
6a2cd888
SBS		 1141 # Check if encryption option active.
1142 if [[ "$OPTION_ENCRYPT" = "true" ]] && [[ "$OPTION_RECIPIENTS" = "true" ]]; then
17d49005 1143 if checkapp age; then # Check that age is available.
320ac29c 1144 for pubkey in "${argRecPubKeys[@]}"; do # Validate recipient pubkey strings by forming test message
238775e6 1145 vbm "DEBUG:Testing pubkey string:$pubkey";
320ac29c 1146 if checkAgePubkey "$pubkey" && \
d6ba4173 1147 ( validateInput "$pubkey" "ssh_pubkey" || validateInput "$pubkey" "age_pubkey"); then
ff22a93f 1148 #### Form age recipient string
be9ef23e 1149 recipients="$recipients""-r '$pubkey' ";
405ce7df 1150 vbm "STATUS:Added pubkey for forming age recipient string:""$pubkey";
77361307 1151 vbm "DEBUG:recipients:""$recipients";
ff22a93f
SBS		 1152 #### Add validated pubkey to recPubKeysValid array
1153 recPubKeysValid+=("$pubkey") && vbm "DEBUG:recPubkeysValid:pubkey added:$pubkey";
408a342b
SBS		 1154 else
1155 yell "ERROR:Exit code ""$?"". Invalid recipient pubkey string. Exiting."; exit 1;
6a2cd888 1156 fi;
17d49005 1157 done
320ac29c 1158 vbm "DEBUG:Finished processing argRecPubKeys array";
52f05d07
SBS		 1159 vbm "STATUS:Array of validated pubkeys:${recPubKeysValid[*]}";
1160 recPubKeysValidStatic=("${recPubKeysValid[@]}"); # Save static image of pubkeys validated by this function
ff22a93f
SBS		 1161
1162 ## Form age command string
be9ef23e
SBS		 1163 CMD_ENCRYPT="age ""$recipients " && vbm "CMD_ENCRYPT:$CMD_ENCRYPT";
1164 CMD_ENCRYPT_SUFFIX=".age" && vbm "CMD_ENCRYPT_SUFFIX:$CMD_ENCRYPT_SUFFIX";
17d49005
SBS		 1165 else
1166 yell "ERROR:Encryption enabled but \"age\" not found. Exiting."; exit 1;
6a2cd888 1167 fi;
408a342b 1168 else
be9ef23e
SBS		 1169 CMD_ENCRYPT="tee /dev/null " && vbm "CMD_ENCRYPT:$CMD_ENCRYPT";
1170 CMD_ENCRYPT_SUFFIX="" && vbm "CMD_ENCRYPT_SUFFIX:$CMD_ENCRYPT_SUFFIX";
408a342b 1171 vbm "DEBUG:Encryption not enabled."
6a2cd888
SBS		 1172 fi;
1173 # Catch case if '-e' is set but '-r' or '-R' is not
1174 if [[ "$OPTION_ENCRYPT" = "true" ]] && [[ ! "$OPTION_RECIPIENTS" = "true" ]]; then
2af0d7d9 1175 yell "ERROR:\\'-e\\' set but no \\'-r\\' or \\'-R\\' set."; exit 1; fi;
6a2cd888
SBS		 1176 # Catch case if '-r' or '-R' set but '-e' is not
1177 if [[ ! "$OPTION_ENCRYPT" = "true" ]] && [[ "$OPTION_RECIPIENTS" = "true" ]]; then
2af0d7d9 1178 yell "ERROR:\\'-r\\' or \\'-R\\' set but \\'-e\\' is not set."; exit 1; fi;
320ac29c
SBS		 1179} # Populate recPubKeysValid with argRecPubKeys; form encryption cmd string and filename suffix
1180magicParseCompressionArg() {
1181 # Desc: Parses compression arguments specified by '-c' option
1182 # Input: vars: OPTION_COMPRESS
1183 # Output: CMD_COMPRESS, CMD_COMPRESS_SUFFIX
1184 # Depends: checkapp(), vbm(), gzip,
408a342b
SBS		 1185 if [[ "$OPTION_COMPRESS" = "true" ]]; then # Check if compression option active
1186 if checkapp gzip; then # Check if gzip available
be9ef23e
SBS		 1187 CMD_COMPRESS="gzip " && vbm "CMD_COMPRESS:$CMD_COMPRESS";
1188 CMD_COMPRESS_SUFFIX=".gz" && vbm "CMD_COMPRESS_SUFFIX:$CMD_COMPRESS_SUFFIX";
408a342b
SBS		 1189 else
1190 yell "ERROR:Compression enabled but \"gzip\" not found. Exiting."; exit 1;
286d9825 1191 fi
408a342b 1192 else
be9ef23e
SBS		 1193 CMD_COMPRESS="tee /dev/null " && vbm "CMD_COMPRESS:$CMD_COMPRESS";
1194 CMD_COMPRESS_SUFFIX="" && vbm "CMD_COMPRESS_SUFFIX:$CMD_COMPRESS_SUFFIX";
1b0e6227 1195 vbm "DEBUG:Compression not enabled.";
320ac29c
SBS		 1196 fi
1197} # Form compression cmd string and filename suffix
1198magicInitWorkingDir() {
1199 # Desc: Determine temporary working directory from defaults or user input
c9c573da
SBS		 1200 # Usage: magicInitWorkignDir
1201 # Input: vars: OPTION_TEMPDIR, argTempDirPriority, DIR_TMP_DEFAULT
320ac29c
SBS		 1202 # Input: vars: SCRIPT_TIME_START
1203 # Output: vars: DIR_TMP
1204 # Depends: processArguments(), vbm(), yell()
1205 # Parse '-t' option (user-specified temporary working dir)
1206 ## Set DIR_TMP_PARENT to user-specified value if specified
1207 local DIR_TMP_PARENT
1208
1209 if [[ "$OPTION_TMPDIR" = "true" ]]; then
1210 if [[ -d "$argTempDirPriority" ]]; then
1211 DIR_TMP_PARENT="$argTempDirPriority";
1212 else
c9c573da 1213 yell "WARNING:Specified temporary working directory not valid:$argTempDirPriority";
320ac29c
SBS		 1214 exit 1; # Exit since user requires a specific temp dir and it is not available.
1215 fi;
1216 else
1217 ## Set DIR_TMP_PARENT to default or fallback otherwise
1218 if [[ -d "$DIR_TMP_DEFAULT" ]]; then
1219 DIR_TMP_PARENT="$DIR_TMP_DEFAULT";
1220 elif [[ -d /tmp ]]; then
1221 yell "WARNING:$DIR_TMP_DEFAULT not available. Falling back to /tmp .";
1222 DIR_TMP_PARENT="/tmp";
1223 else
1224 yell "ERROR:No valid working directory available. Exiting.";
1225 exit 1;
1226 fi
1227 fi;
1228 ## Set DIR_TMP using DIR_TMP_PARENT and nonce (SCRIPT_TIME_START)
1229 DIR_TMP="$DIR_TMP_PARENT"/"$SCRIPT_TIME_START""..bkgpslog" && vbm "DEBUG:Set DIR_TMP to:$DIR_TMP"; # Note: removed at end of main().
1230} # Sets working dir
2af0d7d9
SBS		 1231magicParseCustomTTL() {
1232 # Desc: Set user-specified TTLs for buffer and script
1233 # Input: vars: argCustomBufferTTL (integer), argCustomScriptTTL_TE (string)
1234 # Input: vars: OPTION_CUSTOM_BUFFERTTL, OPTION_CUSTOM_SCRIPTTTL
1235 # Input: vars: BUFFER_TTL (integer), SCRIPT_TTL_TE (string)
1236 # Output: BUFFER_TTL (integer), SCRIPT_TTL_TE (string)
1237 # Depends validateInput(), showUsage(), yell
1238
1239 # React to '-b, --buffer-ttl' option
1240 if [[ "$OPTION_CUSTOM_BUFFERTTL" = "true" ]]; then
1241 ## T: Check if argCustomBufferTTL is an integer
1242 if validateInput "$argCustomBufferTTL" "integer"; then
1243 ### T: argCustomBufferTTL is an integer
1244 BUFFER_TTL="$argCustomBufferTTL";
1245 else
1246 ### F: argcustomBufferTTL is not an integer
1247 yell "ERROR:Invalid integer argument for custom buffer time-to-live."; showUsage; exit 1;
1248 fi;
1249 ## F: do not change BUFFER_TTL
1250 fi;
1251
1252 # React to '-B, --script-ttl' option
1253 if [[ "$OPTION_CUSTOM_SCRIPTTTL_TE" = "true" ]]; then
1254 ## T: Check if argCustomScriptTTL is a time element (ex: "day", "hour")
1255 if validateInput "$argCustomScriptTTL" "time_element"; then
1256 ### T: argCustomScriptTTL is a time element
1257 SCRIPT_TTL_TE="$argCustomScriptTTL";
1258 else
1259 ### F: argcustomScriptTTL is not a time element
1260 yell "ERROR:Invalid time element argument for custom script time-to-live."; showUsage; exit 1;
1261 fi;
1262 ## F: do not change SCRIPT_TTL_TE
1263 fi;
1264} # Sets custom script or buffer TTL if specified
1265
032f4b05 1266
320ac29c
SBS		 1267main() {
1268 # Process arguments
1269 processArguments "$@";
1270 ## Act upon arguments
1271 ### Determine working directory
c9c573da 1272 magicInitWorkingDir; # Sets DIR_TMP from argTempDirPriority
320ac29c
SBS		 1273 ### Set output encryption and compression option strings
1274 #### React to "-r" ("encryption recipients") option
6010b172 1275 magicParseRecipientArgs; # Updates recPubKeysValid, CMD_ENCRYPT[_SUFFIX] from argRecPubKeys
320ac29c 1276 #### React to "-c" ("compression") option
50324e94 1277 magicParseCompressionArg; # Updates CMD_COMPRESS[_SUFFIX]
320ac29c 1278 #### React to "-R" ("recipient directory") option
50324e94 1279 magicParseRecipientDir; # Updates recPubKeysValid
2af0d7d9
SBS		 1280 #### React to custom buffer and script TTL options ("-b", "-B")
1281 magicParseCustomTTL; # Sets custom SCRIPT_TTL_TE and/or BUFFER_TTL if specified
320ac29c
SBS		 1282
1283 # Check that critical apps and dirs are available, display missing ones.
1284 if ! checkapp gpspipe tar && ! checkdir "$DIR_OUT" "DIR_TMP"; then
6c30388f
SBS		 1285 yell "ERROR:Critical components missing.";
1286 displayMissing; yell "Exiting."; exit 1; fi
1287
2af0d7d9
SBS		 1288 # Set script lifespan (SCRIPT_TTL from SCRIPT_TTL_TE)
1289 magicSetScriptTTL "$SCRIPT_TTL_TE";
1290 ## Note: SCRIPT_TTL_TE is time element string (ex: "day") while SCRIPT_TTL is integer seconds
6c30388f 1291
2af0d7d9
SBS		 1292 # File name substring (ISO-8601 duration from BUFFER_TTL)
1293 bufferTTL_STR="$(timeDuration "$BUFFER_TTL")";
6c30388f
SBS		 1294
1295 # Init temp working dir
3a7b92f8 1296 try mkdir "$DIR_TMP" && vbm "DEBUG:Working dir creatd at:$DIR_TMP";
6c30388f
SBS		 1297
1298 # Initialize 'tar' archive
1299 ## Define output tar path (note: each day gets *one* tar file (Ex: "20200731..hostname_location.[.gpx.gz].tar"))
9efeccb5
SBS		 1300 PATHOUT_TAR="$DIR_OUT"/"$(dateShort)".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
1301 vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
f6fb18bd
SBS		 1302 ## Check that PATHOUT_TAR is a tar. Rename old and create empty one otherwise.
1303 checkMakeTar "$PATHOUT_TAR" && vbm "DEBUG:Confirmed or Created to be a tar:$PATHOUT_TAR";
6c30388f 1304 ## Append VERSION file to PATHOUT_TAR
3395ae22 1305 magicWriteVersion;
e47e8048
SBS		 1306
1307 # Define GPS conversion commands
1308 CMD_CONV_NMEA="tee /dev/null " && vbm "STATUS:Set CMD_CONV_NMEA to:$CMD_CONV_NMEA"; # tee as passthrough
1309 CMD_CONV_GPX="gpsbabel -i nmea -f - -o gpx -F - " && vbm "STATUS:Set CMD_CONV_GPX to:$CMD_CONV_GPX"; # convert NMEA to GPX
1310 CMD_CONV_KML="gpsbabel -i nmea -f - -o kml -F - " && vbm "STATUS:Set CMD_CONV_KML to:$CMD_CONV_KML"; # convert NMEA to KML
811f50f2 1311
e47e8048 1312 # MAIN LOOP:Record gps data until script lifespan ends
52f05d07 1313 timeBufferFirstNS="$(timeEpochNS)"; bufferRound=0
2af0d7d9 1314 while [[ "$SECONDS" -lt "$SCRIPT_TTL" ]]; do
52f05d07 1315 magicParseRecipientDir;
811f50f2 1316 magicGatherWriteBuffer &
52f05d07
SBS		 1317 magicBufferSleepPID; # Calculates BUFFER_TTL_ADJ from BUFFER_TTL given buffer expected start time vs. actual
1318 sleep "$BUFFER_TTL_ADJ_FLOAT";
1319 ((bufferRound++));
811f50f2 1320 done
cfc25c90 1321
e47e8048
SBS		 1322 # Cleanup
1323 ## Remove DIR_TMP
cfc25c90 1324 try rm -r "$DIR_TMP";
0aabe6a3 1325
1b0e6227 1326 vbm "STATUS:Main function finished.";
8fbca23d
SBS		 1327} # Main function.
1328#===END Declare local script functions===
1329#==END Define script parameters==
032f4b05
SBS		 1330
1331
8fbca23d
SBS		 1332#==BEGIN Perform work and exit==
1333main "$@" # Run main function.
1334exit 0;
1335#==END Perform work and exit==
Environment Sensor Ninfacyzga-01