type function_sentinel &>/dev/null
if [ $? -eq 0 ]; then
# there was no error, so we can skip the inits.
- if [ ! -z "$SHELL_DEBUG" ]; then
+ if [ ! -z "$DEBUG_FEISTY_MEOW" ]; then
echo "skipping function definitions, because already defined."
fi
skip_all=yes
if [ -z "$skip_all" ]; then
- if [ ! -z "$SHELL_DEBUG" ]; then
+ if [ ! -z "$DEBUG_FEISTY_MEOW" ]; then
echo "feisty meow function definitions beginning now..."
fi
return $?
}
+ ##############
+
# displays the value of a variable in bash friendly format.
function var() {
HOLDIFS="$IFS"
IFS="$HOLDIFS"
}
+ ##############
+
# when passed a list of things, this will return the unique items from that list as an echo.
function uniquify()
{
fi
}
+ ##############
+
function success_sound()
{
if [ ! -z "$CLAM_FINISH_SOUND" ]; then
fi
}
+ ##############
+
+ # echoes the maximum number of columns that the terminal supports. usually
+ # anything you print to the terminal with length less than (but not equal to)
+ # maxcols will never wrap.
+ function get_maxcols()
+ {
+ # calculate the number of columsn in the terminal.
+ local cols=$(stty size | awk '{print $2}')
+ echo $cols
+ }
+
+ ##############
+
# checks the result of the last command that was run, and if that failed,
# then this complains and exits from bash. the function parameters are
# used as the message to print as a complaint.
- function check_result()
+ function test_or_die()
{
if [ $? -ne 0 ]; then
- echo -e "failed on: $*"
+ echo -e "\n\naction failed: $*\n\nExiting script..."
error_sound
exit 1
fi
}
+ # like test_or_die, but will keep going after complaining.
+ function test_or_continue()
+ {
+ if [ $? -ne 0 ]; then
+ echo -e "\n\nerror occurred: $*\n\nContinuing script..."
+ error_sound
+ fi
+ }
+
+ ##############
+
+ # wraps secure shell with some parameters we like, most importantly to enable X forwarding.
+ function ssh()
+ {
+ local args=($*)
+ # we remember the old terminal title, then force the TERM variable to a more generic
+ # version for the other side (just 'linux'); we don't want the remote side still
+ # thinking it's running xterm.
+ save_terminal_title
+#hmmm: why were we doing this? it scorches the user's logged in session, leaving it without proper terminal handling.
+# # we save the value of TERM; we don't want to leave the user's terminal
+# # brain dead once we come back from this function.
+# local oldterm="$TERM"
+# export TERM=linux
+ /usr/bin/ssh -X -C "${args[@]}"
+# # restore the terminal variable also.
+# TERM="$oldterm"
+ restore_terminal_title
+ }
+
+ ##############
+
# locates a process given a search pattern to match in the process list.
# supports a single command line flag style parameter of "-u USERNAME";
# if the -u flag is found, a username is expected afterwards, and only the
fi
}
+ ##############
+
+#hmmm: holy crowbars, this is an old one. do we ever still have any need of it?
# an unfortunately similarly named function to the above 'ps' as in process
# methods, but this 'ps' stands for postscript. this takes a postscript file
# and converts it into pcl3 printer language and then ships it to the printer.
done
}
-# function fix_alsa() {
-# sudo /etc/init.d/alsasound restart
-# }
+#hmmm: not really doing anything yet; ubuntu seems to have changed from pulseaudio in 17.04?
+ # restarts the sound driver.
+ function fix_sound_driver() {
+ # stop bash complaining about blank function body.
+ local nothing=
+#if alsa something
+# sudo service alsasound restart
+#elif pulse something
+# sudo pulseaudio -k
+# sudo pulseaudio -D
+#else
+# something else...?
+#fi
+
+ }
function screen() {
save_terminal_title
# sudo function wraps the normal sudo by ensuring we replace the terminal
# label if they're doing an su with the sudo.
function sudo() {
-# local first_command="$1"
save_terminal_title
/usr/bin/sudo "$@"
+ retval=$?
restore_terminal_title
# if [ "$first_command" == "su" ]; then
# # yep, they were doing an su, but they're back now.
# label_terminal_with_info
# fi
+ return $retval
}
# trashes the .#blah files that cvs and subversion leave behind when finding conflicts.
echo "The nechung oracle program cannot be found. You may want to consider"
echo "rebuilding the feisty meow applications with this command:"
echo "bash $FEISTY_MEOW_SCRIPTS/generator/produce_feisty_meow.sh"
+ echo
else
$wheres_nechung
fi
echo "but that folder does not exist. Skipping customization."
return 1
fi
+
+ # prevent permission foul-ups.
+#hmmm: save error output here instead of muting it.
+#hmmm: better yet actually, just don't complain on freaking cygwin, since that's where this happens
+ chown -R "$(logname):$(logname)" \
+ "$FEISTY_MEOW_LOADING_DOCK"/* "$FEISTY_MEOW_GENERATED_STORE"/* 2>/dev/null
+ test_or_continue "chowning to $(logname) didn't happen."
+
regenerate >/dev/null
pushd "$FEISTY_MEOW_LOADING_DOCK/custom" &>/dev/null
incongruous_files="$(bash "$FEISTY_MEOW_SCRIPTS/files/list_non_dupes.sh" "$FEISTY_MEOW_SCRIPTS/customize/$custom_user" "$FEISTY_MEOW_LOADING_DOCK/custom")"
-
+
+ local fail_message="\n
+are the perl dependencies installed? if you're on ubuntu or debian, try this:\n
+ $(grep "apt-get.*perl" $FEISTY_MEOW_APEX/readme.txt)\n
+or if you're on cygwin, then try this (if apt-cyg is available):\n
+ $(grep "apt-cyg.*perl" $FEISTY_MEOW_APEX/readme.txt)\n";
+
#echo "the incongruous files list is: $incongruous_files"
# disallow a single character result, since we get "*" as result when nothing exists yet.
if [ ${#incongruous_files} -ge 2 ]; then
echo "cleaning unknown older overrides..."
perl "$FEISTY_MEOW_SCRIPTS/files/safedel.pl" $incongruous_files
+ test_or_continue "running safedel. $fail_message"
echo
fi
popd &>/dev/null
echo "copying custom overrides for $custom_user"
mkdir -p "$FEISTY_MEOW_LOADING_DOCK/custom" 2>/dev/null
perl "$FEISTY_MEOW_SCRIPTS/text/cpdiff.pl" "$FEISTY_MEOW_SCRIPTS/customize/$custom_user" "$FEISTY_MEOW_LOADING_DOCK/custom"
+ test_or_continue "running cpdiff. $fail_message"
+
if [ -d "$FEISTY_MEOW_SCRIPTS/customize/$custom_user/scripts" ]; then
echo "copying custom scripts for $custom_user"
- \cp -R "$FEISTY_MEOW_SCRIPTS/customize/$custom_user/scripts" "$FEISTY_MEOW_LOADING_DOCK/custom/"
+ rsync -avz "$FEISTY_MEOW_SCRIPTS/customize/$custom_user/scripts" "$FEISTY_MEOW_LOADING_DOCK/custom/" &>/dev/null
+ test_or_continue "copying customization scripts"
+#hmmm: could save output to show if an error occurs.
fi
echo
regenerate
+ # prevent permission foul-ups, again.
+ chown -R "$(logname):$(logname)" \
+ "$FEISTY_MEOW_LOADING_DOCK" "$FEISTY_MEOW_GENERATED_STORE" 2>/dev/null
+ test_or_continue "chowning to $(logname) didn't happen."
+
restore_terminal_title
}
return 0
}
- # defines a variable within the feisty meow environment and remembers that
- # this is a new or modified definition. if the feisty meow codebase is
- # unloaded, then so are all the variables that were defined.
- # this function always exports the variables it defines.
-# function define_yeti_variable()
-# {
-## if variable exists already, save old value for restore,
-## otherwise save null value for restore,
-## have to handle unsetting if there was no prior value of one
-## we newly defined.
-## add variable name to a list of feisty defined variables.
-#
-##hmmm: first implem just sets it up and exports the variable.
-## i.e., this method always exports.
-#export "${@}"
-#
-#
-#return 0
-# }
-
##############
#hmmm: this points to an extended functions file being needed; not all of these are core.
if [ -d "$src" ]; then
ln -s "$src" "$target"
- check_result "Creating symlink from '$src' to '$target'"
+ test_or_die "Creating symlink from '$src' to '$target'"
fi
echo "Created symlink from '$src' to '$target'."
}
+ # pretty prints the json files provided as parameters.
+ function clean_json()
+ {
+ if [ -z "$*" ]; then return; fi
+ local show_list=()
+ while true; do
+ local file="$1"; shift
+ if [ -z "$file" ]; then break; fi
+ if [ ! -f "$file" ]; then "echo File '$file' does not exist."; continue; fi
+ temp_out="$TMP/$file.view"
+ cat "$file" | python -m json.tool > "$temp_out"
+ show_list+=($temp_out)
+ test_or_continue "pretty printing '$file'"
+ done
+ filedump "${show_list[@]}"
+ rm "${show_list[@]}"
+ }
+
+ function json_text()
+ {
+ # only print our special headers or text fields.
+ local CR=$'\r'
+ local LF=$'\n'
+ clean_json $* |
+ grep -i "\"text\":\|^=.*" |
+ sed -e "s/\\\\r/$CR/g" -e "s/\\\\n/\\$LF/g"
+ }
+
+ ##############
+
+ # echoes the machine's hostname. can be used like so:
+ # local my_host=$(get_hostname)
+ function get_hostname()
+ {
+ # there used to be more variation in how to do this, but adopting mingw
+ # and cygwin tools really helped out.
+ local this_host=unknown
+ if [ "$OS" == "Windows_NT" ]; then
+ this_host=$(hostname)
+ elif [ ! -z "$(echo $MACHTYPE | grep apple)" ]; then
+ this_host=$(hostname)
+ elif [ ! -z "$(echo $MACHTYPE | grep suse)" ]; then
+ this_host=$(hostname --long)
+ elif [ -x "$(which hostname 2>/dev/null)" ]; then
+ this_host=$(hostname)
+ fi
+ echo "$this_host"
+ }
+
+ # makes sure that the provided "folder" is a directory and is writable.
+ function test_writeable()
+ {
+ local folder="$1"; shift
+ if [ ! -d "$folder" -o ! -w "$folder" ]; then return 1; fi
+ return 0
+ }
+
+ ##############
+
+ # given a filename and a string to seek and a number of lines, then this
+ # function will remove the first occurrence of a line in the file that
+ # matches the string, and it will also axe the next N lines as specified.
+ function create_chomped_copy_of_file()
+ {
+ local filename="$1"; shift
+ local seeker="$1"; shift
+ local numlines=$1; shift
+
+#echo into create_chomped_copy...
+#var filename seeker numlines
+
+ # make a backup first, oy.
+ \cp -f "$filename" "/tmp/$(basename ${filename}).bkup-${RANDOM}"
+ test_or_die "backing up file: $filename"
+
+ # make a temp file to write to before we move file into place in bind.
+ local new_version="/tmp/$(basename ${filename}).bkup-${RANDOM}"
+ \rm -f "$new_version"
+ test_or_die "cleaning out new version of file from: $new_version"
+
+ local line
+ local skip_count=0
+ local found_any=
+ while read line; do
+ # don't bother looking at the lines if we're already in skip mode.
+ if [[ $skip_count == 0 ]]; then
+ # find the string they're seeking.
+ if [[ ! "$line" =~ .*${seeker}.* ]]; then
+ # no match.
+ echo "$line" >> "$new_version"
+ else
+ # a match! start skipping. we will delete this line and the next N lines.
+ ((skip_count++))
+#echo first skip count is now $skip_count
+ found_any=yes
+ fi
+ else
+ # we're already skipping. let's keep going until we hit the limit.
+ ((skip_count++))
+#echo ongoing skip count is now $skip_count
+ if (( $skip_count > $numlines )); then
+ echo "Done skipping, and back to writing output file."
+ skip_count=0
+ fi
+ fi
+ done < "$filename"
+
+#echo file we created looks like this:
+#cat "$new_version"
+
+ if [ ! -z "$found_any" ]; then
+ # put the file back into place under the original name.
+ \mv "$new_version" "$filename"
+ test_or_die "moving the new version into place in: $filename"
+ else
+ # cannot always be considered an error, but we can at least gripe.
+ echo "Did not find any matches for seeker '$seeker' in file: $filename"
+ fi
+ }
+
##############
# NOTE: no more function definitions are allowed after this point.
return 0;
}
- if [ ! -z "$SHELL_DEBUG" ]; then echo "feisty meow function definitions done."; fi
+ if [ ! -z "$DEBUG_FEISTY_MEOW" ]; then echo "feisty meow function definitions done."; fi
##############
echo running tests on set_var_if_undefined.
flagrant=petunia
set_var_if_undefined flagrant forknordle
- check_result "testing if defined variable would be whacked"
+ test_or_die "testing if defined variable would be whacked"
if [ $flagrant != petunia ]; then
echo set_var_if_undefined failed to leave the test variable alone
exit 1