#!/bin/bash
#shellcheck disable=1090 disable=2012

                            #-----------------#
                            #@@@@@@@@@@@@@@@@@#
                            #---ERROR CODES---#
                            #@@@@@@@@@@@@@@@@@#
                            #-----------------#

E_permission=10 # No permission for access or file does not exist
E_depends=11    # Lacking required software
E_args=12       # Bad command line arguments or arguments specify illegal
                # action
E_template=13   # Problem with a template
E_extcom=14     # An external command failed
E_xml=15        # Malformed XML or issue processing XML
E_libvirt=16    # Invokation of a libvirt tool was unsuccesful
E_timeout=17    # Timeout was exceeded before spice connection to clone
                # was established
E_file=18       # Expected file does not exist or is of wrong type/format
E_unexpected=19 # Probably a bug in qq2clone

           #---------------------------------------------------#
           #@@@#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
           #---NAMED PIPE FOR PASSING DATA BETWEEN FUNCTIONS---#
           #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
           #---------------------------------------------------#

#=========================================================================#
check_pipe ()
# DESCRIPTION: See if pipe is open
# INPUT: None
# OUTPUT: Return value
# PARAMETERS: None
#=========================================================================#
{
local type
type="$(file -bL /proc/self/fd/3)"
if [[ ! "$type" =~ fifo ]]; then
  return 1
fi
return 0
}
#=========================================================================#
open_pipe ()
# DESCRIPTION: Open a named pipe in read/write mode on fd3
# INPUT: None
# OUTPUT: None
# PARAMETERS: None
#=========================================================================#
{
check_pipe && return
local TEMPDIR
TEMPDIR=$(mktemp -d) || temp_error
#shellcheck disable=2064
trap "exec 3>&-; exec 3<&-;rm -rf $TEMPDIR" EXIT
fifo_path="${TEMPDIR}/qq2clone_fifo"
mkfifo "$fifo_path" ||
  { echo "Cannot make fifo" >&2; exit "$E_extcom" ;}
exec 3<>"$fifo_path"
return 0
}
#=========================================================================#
read_pipe ()
# DESCRIPTION: Flushes the contents of the named pipe to stdout, 
#   nonblocking
# INPUT: None
# OUTPUT: Contents of named pipe on fd3
# PARAMETERS: $1: (Optional) If 1, read data out but also write it back
#   into the pipe
#=========================================================================#
{
# Note: This implementation allows for things like this to work:
# tr "a" "b" < <(read_pipe) | write_pipe 1
echo "EOF" >&3
local line match
while IFS= read -r line <&3; do
  # write_pipe puts a + at the start of every line for read_pipe
  if [[ "$line" =~ ^\+(.*)$ ]]; then
    match="${BASH_REMATCH[1]}"
    echo "$match"
    (($#)) && (($1 == 1)) && write_pipe 0 "$match"
  else
    break
  fi
done
return 0
}
#=========================================================================#
write_pipe ()
# DESCRIPTION: Write information to the named pipe, nonblocking unless it
#   is told to look for input on stdin and nothing is sent there. Works in
#   conjunction with read_pipe to make read_pipe non-blocking
# INPUT: Tell write_pipe whether information is coming on stdin or from
#   a parameter, then pass information
# OUTPUT: None
# PARAMETERS: $1: '0' if passing another parameter(s), '1' if writing to 
#   stdin instead.
#   $2 and on: If $1 is 0, this is the information write_pipe will 
#   write as "$*"
#=========================================================================#
{
# We put a + at the beginning of every line to let read_pipe work in a
# non-blocking manner
if (($1)); then
 local line
  while IFS= read -r line; do 
    echo "+$line" >&3
  done
else
  shift
  echo "+$*" >&3
fi
return 0
}

              #-------------------------------------------#
              #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
              #---GET/ALTER CONFIGURATION, CHECK SYSTEM---#
              #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
              #-------------------------------------------#
              
#=========================================================================#
check_config ()
#=  DESCRIPTION: Given a name or name/value pair, check if it is a
#=    valid configuration option
#=  INPUT: Either a name or name value pair
#=  OUTPUT: Return 1 if the name is not a valid config option or if the
#=    given value does is not valid for the given name. Return 0 else
#=  PARAMETERS: $1: Name of config option, $2: (optional) value of option
#=========================================================================#
{
(($#)) || unexpected_error check_config
declare -A def_opt
def_opt[TEMPLATE]=".*"
def_opt[TEMPLATE_DIR]="^/.*"
def_opt[QUIET]="^[01]$"
def_opt[USE_SPICE]="^[01]$"
def_opt[SPICY]="^[01]$"
def_opt[S_TIMEOUT]="^[0-9]+$"
def_opt[NORUN]="^[01]$"
def_opt[STORAGE]="^/.*"

(( $# == 1 )) && 
  { [[ " ${!def_opt[*]} " =~  [[:space:]]${1}[[:space:]] ]];
    return $?; }
    
local patt="${def_opt["${1}"]}"
[[ -n "$patt" ]] || return 1
[[ "$2" =~ $patt ]] || return 1

return 0
}
#=========================================================================#
check_depends ()
# DESCRIPTION: Check that required software is present during initial auto-
#   configuration
# INPUT: None
# OUTPUT: Return 0 on success or exits with descriptive message on failure
# PARAMETERS: None
#=========================================================================#
{
local elem missing=0

# These we need to check for
local -a depends=( virsh virt-clone virt-xml virt-xml-validate qemu-img \
  xmllint )

# These are from gnu-coreutils, util-linux, or are simply extremely common
# and almost certainly present.  However, checking for any external 
#command invoked is harmless and may even help 1/10000 times
depends=( "${depends[@]}" basename chmod date dirname file grep less ls \
  md5sum mkfifo mkdir mktemp mv rm sed sort touch uniq uuidgen uuidparse \
  vi dirname )

(( BASH_VERSINFO[0] >= 4 )) ||
  { echo "This script must be run with Bash version 4.0+"
    exit "$E_depends"; } >&2

for elem in "${depends[@]}"; do
  if ! { command -v "$elem"; } &>/dev/null; then 
    ((missing++))
    echo "Missing required software: $elem" >&2
  fi
done

((missing)) &&
  { echo "This script won't run until you install the listed software" >&2;
  exit "$E_depends"; } 
  
  return 0
}
#=========================================================================#
disp_conf_names ()
# DESCRIPTION: Display the name and value of all configuration options
# INPUT: None
# OUTPUT: Echoes config name="value" pairs
# PARAMETERS: None
#=========================================================================#
{
local name value
while read -r name; do
  read -r value
  echo "'$name'='$value'"
done < <(sqlite3 "select name,value from CONFIG")
return 0
}
#=========================================================================#
disp_conf_desc ()
# DESCRIPTION: Display the description of a config option to the user
# INPUT: The name of the option
# OUTPUT: Echoes relevant lines of information
# PARAMETERS: $1: The config option name
#=========================================================================#
{
if [[ "$1" == "TEMPLATE_DIR" ]]; then
  echo "This is the where template XML files will be kept"
  echo
  echo "Default value: '${QQ2_DIR}/templates'"
elif [[ "$1" == "TEMPLATE" ]]; then
  echo "This template will be used for commands like clone, rm, destroy"
  echo "when option --template/-t is not specified"
  echo
  echo "Default value: '' (empty, disabled)"
elif [[ "$1" == "QUIET" ]]; then
  echo "If set to 1, most non-error output will be suppressed"
  echo
  echo "Default value: '0'"
elif [[ "$1" == "SPICY" ]]; then
  echo "If set to 1, use spicy as the default spice client instead of"
  echo "virt-viewer. If virt-viewer is installed during the initial setup,"
  echo "the default value is '1' (enabled). Otherwise, the default value"
  echo "is '0'"
elif [[ "$1" == "USE_SPICE" ]]; then
  echo "If set to 1, attempt to connect to the spice graphics of a virtual"
  echo "machine by default when cloning it, if it is configured to use"
  echo "spice graphics. qq2clone can do this using the programs spicy and" 
  echo "virt-viewer. If either is installed on your system during the"
  echo "first run, the default value is '1' (enabled). Otherwise, the"
  echo "default value is '0'"
elif [[ "$1" == "S_TIMEOUT" ]]; then
  echo "Wait this many seconds before timing out when trying to connect to"
  echo "a virtual machine's spice graphics."
  echo
  echo "Default value: '10'"
elif [[ "$1" == "NORUN" ]]; then
  echo "If set to 1, do not automatically run a machine after cloning it."
  echo
  echo "Default value: '0'"
elif [[ "$1" == "STORAGE" ]]; then
  echo "The default location to store clone images when creating them."
  echo "Changing this location is fine, but it is a good idea to ensure"
  echo "that whatever location you do choose is only used by qq2clone"
  echo
  echo "Default value: '${QQ2_DIR}/qq2clone-pool'"
else  
  echo "No such configuration option '$1'"
  return 1
fi
return 0
}
first_run_setup ()
# DESCRIPTION: Generate a new database with default config values, 
#   create subdirectories of QQ2_DIR
# INPUT: None
# OUTPUT: None
# PARAMETERS: None
#=========================================================================#
{
local QQ2_DIR="${HOME}/storage-qq2clone"
echo "$QQ2_DIR" > "${HOME}/.config/qq2clone"

# Default locations of key directories
local TEMPLATE_DIR="${QQ2_DIR}/templates"
local POOL_DIR="${QQ2_DIR}/qq2clone-pool"

check_rw "$QQ2_DIR"
check_depends

[[ -e "${QQ2_DIR}/qq2clone.db" ]] && return 0

make_dir "$TEMPLATE_DIR"
make_dir "$POOL_DIR"
check_rw -r "$TEMPLATE_DIR" "$POOL_DIR"

chmod +rx "${QQ2_DIR}/sqlite3" &>/dev/null
{ [[ -e "${QQ2_DIR}/sqlite3" ]] && [[ -x "${QQ2_DIR}/sqlite3" ]] &&
  [[ -r "${QQ2_DIR}/sqlite3" ]] ; } ||
  { echo "sqlite3 binary must be present at"
    echo "${QQ2_DIR}/sqlite3"
    echo "and must be readable/executable"
    exit "$E_file"; } >&2

local use_spice spicy
if command -v virt-viewer &>/dev/null; then 
  use_spice=1
  spicy=0
elif command -v spicy &>/dev/null; then
  use_spice=1
  spicy=1
else
  use_spice=0
  spicy=0
fi

sqlite3 <<EOF
  create table CLONES(uuid TEXT, id INTEGER, template TEXT, disks TEXT);
    
  create table TEMPLATES(name TEXT, md5sum TEXT, disks TEXT,\
    valid INTEGER);
  
  create table CONFIG(name TEXT, value TEXT);
  insert into CONFIG values('TEMPLATE_DIR', '${TEMPLATE_DIR}');
  insert into CONFIG values('USE_SPICE', '${use_spice}');
  insert into CONFIG values('SPICY', '${spicy}');
  insert into CONFIG values('QUIET', '0');
  insert into CONFIG values('S_TIMEOUT', '10');
  insert into CONFIG values('STORAGE', '${POOL_DIR}');
  insert into CONFIG values('TEMPLATE', '');
  insert into CONFIG values('NORUN', '0');
EOF

return 0
}
#=========================================================================#
get_config ()
# DESCRIPTION: Load configuration from database
# INPUT: None
# OUTPUT: Error message and exit $E_config if there is a problem, otherwise
#   declare and populate global array OPT
# PARAMETERS: None
#=========================================================================#
{
  declare -g QQ2_DIR
  QQ2_DIR="$(<"${HOME}/.config/qq2clone")"
  QQ2_DIR="$(strip_ws "$QQ2_DIR")"
  [[ -e "$QQ2_DIR/sqlite3" ]] ||
    { echo "The sqlite3 binary is missing from $QQ2_DIR";
      exit "$E_depends"; }
    
local check
read -r check \
  < <(sqlite3 "select exists ( select * from CONFIG)")
((check)) ||
  { echo "Is the database corrupt? No CONFIG table!" 2>/dev/null; 
    unexpected_error get_config; }

declare -gA OPT
declare -a opts
local elem
opts=(TEMPLATE_DIR TEMPLATE QUIET USE_SPICE SPICY S_TIMEOUT NORUN \
  STORAGE)
for elem in "${opts[@]}"; do
  OPT["$elem"]="$(sqlite3 \
    "select value from CONFIG where name=\"$elem\"")"
done
}
#=========================================================================#
write_config ()
# DESCRIPTION: Write an option name and value pair to config table.
#   Checks that the option name and value are good.
# INPUT: Name and value of configuration option
# OUTPUT: Return 0 on success, 1 on bad option, 2 on bad value
# PARAMETERS: $1: Name of variable, $2: Value of variable
#=========================================================================#
{
check_config "$1" || return 1
check_config "$1" "$2" || return 2

sqlite3 "update CONFIG set value='$2' where name='$1';"

return 0
}

                        #-----------------------#
                        #@@@@@@@@@@@@@@@@@@@@@@@#
                        #---USAGE INFORMATION---#
                        #@@@@@@@@@@@@@@@@@@@@@@@#
                        #-----------------------#
#=========================================================================#
usage ()
# DESCRIPTION: Output basic usage information
# INPUT: None
# OUTPUT: Echo information to stdout to be read by the user
# PARAMETERS: None
#=========================================================================#
{
(( OPT[QUIET] )) && return 0
echo "qq2clone: quick qcow2 clone"
echo
echo "Description:"
echo "  Create and manage QEMU/KVM VMs using template machines and qcow2"
echo "  images with backing files"
echo
echo "Usage:"
echo "  qq2clone [OPTION]... [COMMAND] [ARGUMENT]..."
echo  
echo '  options:  --connection/-c (URI) --no-spice/-f --help/-h'
echo '            --no-run/-n --quiet/-q --quieter/-Q --run/-r --spicy/-S'
echo '            --storage/-s (filepath/pool-name) --template/-t (name)'
echo '            --use-spice/-g --verbose/-v --virt-viewer/-V'
echo
echo "  commands: check clone config connect copy-template delete-template"
echo "            destroy edit exec import-template list list-templates"
echo "            modify-template restore resume rm rm-wipe rm-shred save"
echo "            save-rm start suspend"
echo
echo "  For more information, see: man qq2clone"
return 0
}

                  #-----------------------------------#
                  #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
                  #---INPUT/OUTPUT HELPER FUNCTIONS---#
                  #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
                  #-----------------------------------#

                  
#=========================================================================#
prompt_num ()
# DESCRIPTION: Prompt user for a number between $1 and $2
# INPUT: Inclusive endpoints of accepted interval, where the right hand
#   endpoint is less than 10
# OUTPUT: Echo choice when proper input is received
# PARAMETERS: $1: LH of interval, $2: RH of interval
#=========================================================================#
{
{ (( $1 > -1 )) && (( $1 < $2 )) && (( $2 < 10 )) ; } || \
  unexpected_error prompt_num
local n
read -rsn 1 n
{ [[ "$n" =~ ^[0-9]$ ]] && (($1 <= n)) && ((n <= $2)); } || 
  { echo "Enter a number from $1 to $2" >&2;
    prompt_num "$1" "$2";
    return 0; }
echo "$n"
return 0
}
#=========================================================================#
prompt_yes_abort ()
# DESCRIPTION: Prompt user to enter y, or any other key to abort
# INPUT: A keystroke
# OUTPUT: Prompts for input, returns 0 for Y/y and 1 for else
# PARAMETERS: $1, $2: (Optional) override disp with $1 and patt with $2
#=========================================================================#
{
local disp="Press (y) to accept, anthing else to abort" patt="^[Yy]$"
[[ -n "$1" ]] && disp="$1"
[[ -n "$2" ]] && patt="$2"
local char
echo "$disp"
read -rn 1 char
echo
[[ "$char" =~ $patt ]] && return 0
  return 1
}
#=========================================================================#
prompt_yes_no ()
# DESCRIPTION: Prompt user to enter y or n, repeatedly until they do
# INPUT: Keystrokes
# OUTPUT: Prompts for input, returns 1 for N/n or 0 for Y/y
# PARAMETERS: None
#=========================================================================
# 
{
local char
until [[ "$char" =~ ^[YyNn]$ ]]; do
  echo "Press (y)/(n) for yes/no"
  read -rn 1 char
  echo
done
[[ "$char" =~ ^[Nn]$ ]] && return 1
return 0
}

                    #-----------------------------#
                    #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
                    #---PARSE/SEARCH/MODIFY XML---#
                    #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
                    #-----------------------------#

#=========================================================================#
do_virt_xml ()
# DESCRIPTION: Run a given virt-xml command, reading from and writing to
#   the named pipe
# INPUT: Parameters to send to  virt-xml 
# OUTPUT: Nothing except on error
# PARAMETERS: $@: Passed to virt-xml
#=========================================================================#
{
local xml
xml="$(virt-xml "$@" <<<"$(read_pipe)" 2>/dev/null)" ||
  { echo "Attempt to generate xml with virt-xml failed." 
    echo "This is probably a bug in qq2clone"
    exit "$E_unexpected" ; } >&2

write_pipe 1 <<<"$xml"
return 0
}                         
                         
#=========================================================================#
find_tag ()
# DESCRIPTION: Use xmllint to do an xpath search of xml and write_pipe
#   all matches
# INPUT: Xpath and XML
# OUTPUT: Write one match per line
# PARAMETERS: $1: Xpath, $2: XML location, or leave blank to read from
#   stdin
#=========================================================================#
{
if [[ -n "$2" ]]; then
  write_pipe 1 <"$2"
else
  local line
  while read -r line; do
    write_pipe 0 "$line"
  done
fi

xmllint --xpath "$1" --auto |& grep -qi 'xpath error' &&
  unexpected_error find_tag

xmllint --noblanks --dropdtd --nowarning --xpath "$1" \
  2>/dev/null <(read_pipe) | write_pipe 1
 
return 0
}
#=========================================================================#
get_attr_value ()
# DESCRIPTION: Given an attribute="value" pair, echo the value
# INPUT: Attribute value pair
# OUTPUT: Value, or unexpected_error if input doesn't match pattern (do not
#   rely on this function for checking that a string is a name=value pair
# PARAMETERS: $1: attribute="value"
#=========================================================================#
{
p="$(strip_ws "$1")"
[[ "$p" =~ ^[^\=]+\=[[:space:]]*[^[:space:]](.*).$ ]] &&
  { echo "${BASH_REMATCH[1]}"; return 0; }
unexpected_error get_attr_value
return 0
}
#=========================================================================#
get_disk_devices ()
# DESCRIPTION: Find all disk device file locations from an XML file
# INPUT: libvirt domain XML file on stdin
# OUTPUT: writepipe each file location
# PARAMETERS: None
#=========================================================================#
{
find_tag '//devices/disk[@type="file"][@device="disk"]/source/@file'
local line val
while read -r line; do
  val="$(get_attr_value "$line")" || unexpected_error get_disk_devices
  write_pipe 0 "$val"
done < <(read_pipe)
return 0
}
get_disk_devices_db ()
# DESCRIPTION: Like get_disk_devices, but get info from the database
# INPUT: Machine number, or omit to get template info
# OUTPUT: writepipe each file location
# PARAMETERS: $1: (Optional) machine number
#=========================================================================#
{
local query disk
if (($#)); then
  query="select disks from CLONES where id='$1' \
    and template='${OPT[TEMPLATE]}';"
else
  query="select disks from TEMPLATES where name='${OPT[TEMPLATE]}';"
fi
while read -r disk; do
  write_pipe 0 "$disk"
done < <(sqlite3 "$query")
return 0
}
#=========================================================================#
has_spice ()
# DESCRIPTION: Check whether a machine supports spice graphics
# INPUT: A machine number
# OUTPUT: Returns 0 if yes and 1 if no
# PARAMETERS: $1: A machine number
#=========================================================================#
{
local uuid
uuid="${CL_MAP["$1"]}"
find_tag '//devices/graphics[@type="spice"]' < <(virsh dumpxml "$uuid")
local match=0 line
while read -r line; do
  match=1
done < <(read_pipe)
((match)) && return 0
return 1
}

                    #--------------------------------#
                    #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
                    #---FILESYSTEM/DB INTERACTIONS---#
                    #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
                    #--------------------------------#

#=========================================================================#
copy_file ()
# DESCRIPTION: Copy file $1 to $2 and give error messages, exit on error
# INPUT: File to copy
# OUTPUT: Error messages and exit codes as needed
# PARAMETERS: $1: File to copy, $2: Location to copy to
#=========================================================================#
{
(($# == 2)) || unexpected_error copy_file
check_rw "$1" "$(dirname "$2")"
[[ -e "$2" ]] && check_rw "$2"
cp -fR "$1" "$2" &>/dev/null || unexpected_error copy_file
return 0
}
#=========================================================================#
get_md5 ()
# DESCRIPTION: Get md5sum of a file without the trailing filename
# INPUT: A filepath
# OUTPUT: The md5sum
# PARAMETERS: $1: Filepath
#=========================================================================#
{
local md5
check_rw "$1" || unexpected_error get_md5
md5="$(md5sum "$1")"
[[ "$md5" =~ ^[[:space:]]*([^[:space:]]+)([[:space:]]|$) ]]
echo "${BASH_REMATCH[1]}"
return 0
}
#=========================================================================#
make_dir ()
# DESCRIPTION: Make a directory at given location or exit with error 
#   message
# INPUT: Filepath
# OUTPUT: Error messages and exit code as needed
# PARAMETERS: $1: Filepath of directory to make
#=========================================================================#
{
(($# == 1)) || unexpected_error make_dir
if [[ -e "$1" ]]; then
  [[ -d "$1" ]] ||
    { echo "Tried to create directory:"
      echo "$1"
      echo "but it already exists and is not a directory"
      exit "$E_file"; } >&2
  check_rw "$1"
  return 0
fi
mkdir -p "$1" &>/dev/null
check_rw "$1"
return 0
}
#=========================================================================#
move_file ()
# DESCRIPTION: Move file $1 to $2 or give error messages, exit on error
# INPUT: File to move, new location
# OUTPUT: Error messages and exit codes as needed
# PARAMETERS: $1: File to move, $2: Location to move to
#=========================================================================#
{
(($# == 2)) || unexpected_error move_file
check_rw "$1" "$(dirname "$2")"
if [[ -e "$2" ]]; then
    chmod +rw "$2" ||
      { echo "No permission to write $2" >&2; exit "$E_permission"; }
fi
mv -f "$1" "$2" &>/dev/null || unexpected_error move_file
return 0
}
#=========================================================================#
write_file ()
# DESCRIPTION: Write contents of named pipe to file or error and exit
# INPUT: Filepath as parameter, content via write_pipe
# OUTPUT: Error messages and exit codes as needed
# PARAMETERS: $1: Filepath
#=========================================================================#
{
(($# == 1)) || unexpected_error write_file
touch "$1"
check_rw "$1"
[[ -d "$1" ]] && unexpected_error write_file
local temp1 temp2
temp1="$(mktemp)" || temp_error
temp2="$(mktemp)" || { rm -f "$temp1" &>/dev/null; temp_error; }
cp "$1" "$temp1" || 
  { rm -f "$temp1" "$temp2" &>/dev/null; unexpected_error write_file; }
read_pipe > "$temp2" ||
  { rm -f "$temp1" "$temp2" &>/dev/null; unexpected_error write_file; }
mv -f "$temp2" "$1" &> /dev/null ||
  { rm -f "$1" &>/dev/null; mv -f "$temp1" "$1" &>/dev/null;
    rm -f "$temp1" "$temp2" &>/dev/null; unexpected_error write_file; }
return 0
}
#=========================================================================#
sqlite3 ()
# DESCRIPTION: Pass arguments to sqlite3 binary, prepending basic 
#   parameters that are always used
# INPUT: Arguments to sqlite3
# OUTPUT: Dependent on sqlite3
# PARAMETERS: Arbitrary
#=========================================================================#
{
"${QQ2_DIR}/sqlite3" --batch --separator $'\n' "${QQ2_DIR}/qq2clone.db"\
  "$@" || unexpected_error sqlite3
} 

                      #-----------------------------#
                      #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
                      #---IMPORT/MODIFY TEMPLATES---#
                      #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
                      #-----------------------------#

# This section includes only helper functions for functions that import or
# modify templates

#=========================================================================#
commit_image ()
# DESCRIPTION: Commit changes from staging image(s) to template image(s)
# INPUT: Parameters to calling function
# OUTPUT: Status updates, prompts, error messages
# PARAMETERS: $@ from calling function
#=========================================================================#
{
if (( ${#CL_MAP[@]} + ${#BAD_CL[@]} > 1)) && (($# < 3)); then
    echo "This template still has clones. If changes are committed,"
    echo "these clones may become corrupted. To avoid this,"
    echo "retrieve any information you need from these clones"
    echo "and then delete them. Aborting"
    echo
    echo "To continue anyway, append argument \"force\""
    exit "$E_args"
fi

local disk check t d
if (($# < 3)); then
  get_disk_devices_db
  while read -r disk; do
    while read -r t; do
      check="$(sqlite3 "select exists \
        (select * from CLONES where template='$t');")"
      ((check)) || continue
      while read -r d; do
        if [[ "$d" == "$disk" ]]; then
          echo "Although this template has no clones, template"
          echo "$t does. These templates share disk:"
          echo
          echo "  $disk"
          echo
          echo "If changes are committed, these clones may become"
          echo "corrupted. To avoid this, retrieve any information you" 
          echo "need from these clones and then delete them. Aborting."
          echo
          echo "To continue anyway, append argument \"force\""
          exit "$E_args"
        fi >&2
      done < <(sqlite3 "select disks from TEMPLATES where name='$t';")
    done < <(sqlite3 "select name from TEMPLATES where \
      not name='${OPT[TEMPLATE]}';")
  done < <(read_pipe)
fi

if (($# < 3)); then
  echo "This operation has the potential to corrupt your master template"
  echo "image if it is interrupted."
  if ((OPT[QUIET] )); then
    echo "Append argument force to continue" >&2
    exit "$E_args"
  fi
  prompt_yes_abort || exit 0
fi

while read -r disk; do
  ((OPT[QUIET])) || echo "Committing $disk..."
  output="$(qemu-img commit -d "$disk" 2>&1)" ||
    { echo "$output" >&2; echo "Operation failed" >&2;
      exit "$E_unexpected"; }
  rm -f "$disk" &>/dev/null ||
    { echo "Failed to delete old image. Permission issue? " >&2;
      echo "Process may not have completed succesfully" >&2;
      exit "$E_permission"; }
done < <(sqlite3 "select disks from CLONES where id='0' and\
  template='${OPT[TEMPLATE]}';")
delete_machine 0 0

return 0
}
#=========================================================================#
get_template_name ()
# DESCRIPTION: Helper for exec_com_import_template. write_pipes the 
#   original name from the xml, then the new one
# INPUT: XML is write_piped, and argument to exec_com_import_template
#    giving the name to import template with is optionally provided
# OUTPUT: See description. Error messages if name is bad
# PARAMETERS: $1: (optional) Template name, overrides value from XML
#=========================================================================#
{
local name char
name="$(strip_ws "$1")"

if [[ -n "$name" ]]; then
  valid_xml_name_check "$name"
  template_name_available "$name"
fi

local xmlname
find_tag '//name/text()' <<<"$(read_pipe)"
while read -r line; do
  line="$(strip_ws "$line")"
  if [[ -n "$xmlname" ]]; then
    xmlname="${xmlname}${line}"
  else
    xmlname="$line"
  fi
done < <(read_pipe)
write_pipe 0 "$xmlname"

if [[ -z "$name" ]]; then
  name="$xmlname"
fi

write_pipe 0 "$name"
return 0
}
#=========================================================================#
import_get_xml ()
# DESCRIPTION: Determine if argument to exec_com_import_template is a
#   libvirt domain on the current connection or a filepath, check that it 
#   is valid, and write_pipe the xml
# INPUT: argument designating template XML or domain name/uuid
# OUTPUT: Error messages as needed, write_pipes XML on success
# PARAMETERS: $1: $1 from calling funcion
#=========================================================================#
{
if [[ "$1" =~ ^/ ]]; then
  { [[ -e "$1" ]] && [[ -r "$1" ]] ; } ||
    { echo "No read permission for $1 or file does not exist"
      exit "$E_permission" ; } >&2
  virt-xml-validate "$1" &> /dev/null ||
    { virt-xml-validate "$1";
      echo "File $1 is not a valid libvirt domain XML document"
      exit "$E_xml" ; } >&2
  write_pipe 1 <"$1"
else
  virsh dominfo "$1" &>/dev/null ||
  { echo "Cannot access libvirt domain with name/uuid $1. "
    echo "Wrong connection URI? Currently $LIBVIRT_DEFAULT_URI"
    exit "$E_libvirt"; } >&2
  local line uuid
  while read -r line; do
    if [[ "$line" =~ \
      ^[[:space:]]*[Uu][Uu][Ii][Dd]\:[[:space:]]*([^[:space:]]+) ]]; then
        uuid="${BASH_REMATCH[1]}"
    fi
  done < <(virsh dominfo "$1")
  local check=0
  check="$(sqlite3 "select exists (select * from CLONES \
    where uuid='$uuid');")"
  if ((check)); then
    echo "Cannot import a clone as a template" >&2
    exit "$E_template"
  fi
  virsh dumpxml --inactive  "$1" 2>/dev/null | write_pipe 1
fi
return 0
}
#=========================================================================#
rename_template ()
# DESCRIPTION: Change template name, and all of its clone names
# INPUT: A current template name, and a new one
# OUTPUT: Status updates, error messages
# PARAMETERS: $@ from calling function exec_com_modify_template
#=========================================================================#
{
local old_name="$1" new_name="$3"
local tdir="${OPT[TEMPLATE_DIR]}"
local xml="${tdir}/${1}.xml"
check_rw "$xml"

OPT[TEMPLATE]="$old_name"


write_pipe 1 <"$xml"
template_name_available "$new_name"
valid_xml_name_check "$new_name"
do_virt_xml --edit --metadata name="$new_name"

xml="${tdir}/${new_name}.xml"
write_file "$xml"
rm -f "${tdir}/${old_name}.xml" &>/dev/null
sqlite3 "update TEMPLATES set name='${new_name}' where name='${old_name}';"
OPT[TEMPLATE]="$new_name"
check_template &>/dev/null # Just to update md5sum

((OPT[QUIET])) || echo "Template name changed";


if (( ${#CL_MAP[@]} + ${#BAD_CL[@]} )); then
  if ! ((OPT[QUIET] == 2)); then
    echo "Now renaming clones"
    local machines_on
    machines_on="$(get_target_set destroy)"
    [[ -n "$machines_on" ]] &&
      { echo "All clones that are not turned off will not be renamed."
        echo "qq2clone will still know they are clones of $new_name,"
        echo "but in virsh and virt-viewer their old name will remain."
        echo
        echo "Shut down any running clones of $new_name you wish renamed"
        echo "and press enter when ready to proceed."
        read -rs
        echo ; } >&2
  fi
  
  local id uuid cl_name
  while read -r id; do
    read -r uuid
    cl_name="$(unique_name_uuid 0 "${new_name}#$id")"
    virsh domrename "$uuid" "$cl_name" &>/dev/null
    sqlite3 "update CLONES set template='$new_name' where\
      template='$old_name';"
  done < <( sqlite3 "select id,uuid from CLONES where \
    template='$old_name'" )
fi

(( OPT[QUIET] )) || echo "Template rename complete"
exit 0
}
#=========================================================================#
user_undefine_domain ()
# DESCRIPTION: Prompt the user to undefine libvirt domain (or not)
# INPUT: Domain name
# OUTPUT: Gives info to and prompts user
# PARAMETERS: $1: Domain name
#=========================================================================#
{
((OPT[QUIET] == 2)) && return 0
echo
echo "Would you like to undefine the libvirt domain this template"
echo "was made from? This prevents the original domain from being"
echo "accidentally run, altering the template disk and potentially"
echo "corrupting any clones of that template."
echo
echo "This will apply every flag listed in 'man virsh' for command"
echo "'undefine' that may be required to succeed. I.e., snapshot"
echo "and checkpoint metadata, managed save images, etc. will be"
echo "discarded."
echo
if prompt_yes_no; then
  virsh domstate "$1" 2>/dev/null | grep -q "shut off" ||
  virsh domstate "$1" 2>/dev/null | grep -q "crashed" ||
    { echo "This domain is still running, so make sure you turn it off"; 
      echo "before making clones from this template. Otherwise, it will"
      echo "continue modifying the template storage device even"
      echo "though it is undefined."; } >&2
  if virsh undefine --managed-save --checkpoints-metadata\
    --snapshots-metadata --nvram "$1" &> /dev/null; then
    echo "Domain undefined."
  else
    echo "Could not undefine domain. Import still completed."
  fi
fi
}

                      #-------------------------------#
                      #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
                      #---ERROR MESSAGES AND CHECKS---#
                      #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
                      #-------------------------------#
                      
#=========================================================================#
arg_error ()
# DESCRIPTION: If args are too few, too many, or simply wrong, this
#   function provides a concise way to exit with proper message and code
# INPUT:  Type of problem, name of command, name of bad arg
# OUTPUT:  Echo error message, exit with E_args
# PARAMETERS: $1: 0) too few args 1) too many args 2) incorrect arg
#   $2: The command, $3: in the case of incorrect arguments, the bad 
#   argument in question (omit otherwise)
#=========================================================================#
{
local line
if (( $1 == 0 )); then
  echo "Too few arguments to qq2clone $2"
elif (( $1 == 1 )); then
  echo "Too many arguments to qq2clone $2"
else
  echo "Bad argument to qq2clone $2: $3"
fi
exit "$E_args"
} >&2
#=========================================================================#
check_dir ()
# DESCRIPTION: Checks that a directory can be written to
# INPUT: A filepath
# OUTPUT: Error messages and exit codes as needed
# PARAMETERS: $1: Filepath
#=========================================================================#
{
[[ "$1" =~ ^/ ]] ||
  { echo "Invalid filepath $1 specified. Use an absolute filepath";
    exit "$E_args"; }
mkdir -p "$1" &>/dev/null
{ [[ -d "$1" ]]  && [[ -w "$1" ]]; } ||
  { echo "Cannot create $1 or cannot write to directory, check ";
    echo "filepath and permissions";
    exit "$E_permission"; }
return 0
} >&2
#=========================================================================#
check_rw ()
# DESCRIPTION: Provide an error message and exit if specified file cannot
#   be read and written to. If file is a directory and a preceding
#   argument is '-r', check recursively
# INPUT: A filepath (preferably fully qualified as a file could technically
#   be named '-r'
# OUTPUT: Error messages and exit codes as needed
# PARAMETERS: $@: Filepaths to check
#=========================================================================#
{
local redir
if [[ "$1" == "-r" ]]; then 
  redir=1; shift
else
  redir=0
fi
  
while (($#)); do
  if { chmod +rw "$1" || { [[ -w "$1" ]] && [[ -r "$1" ]]; } || 
    readlink "$1" ; } &>/dev/null; 
then
    shift
  elif [[ -e "$1" ]]; then
    echo "No read/write permissions for $1" >&2
    exit "$E_permission"
  else
    echo "The filepath $1 either does not exist or cannot be seen " >&2
    echo "with current permissions"
    exit "$E_permission"
  fi
  local type line
  type="$(file -b "$1")"
  if [[ "$type" =~ directory ]] && ((redir)); then
    while read -r line; do      
      check_rw -r "$line"
    done < <(find "$1" 2>/dev/null)
  fi
done
return 0
} >&2
#=========================================================================#
check_template ()
# DESCRIPTION: Check if OPT[TEMPLATE] is defined. If it is, see if its
#   md5sum is in agreement with the database. If it isn't, update the
#   database and see if it is valid. Make sure that aspect of the db is
#   updated too. Return 1 if template is not defined, or 2 if it is not 
#   valid
# INPUT: None
# OUTPUT: Error message and exit
# PARAMETERS: None
#=========================================================================#
{
local md5 md5_curr valid

check_template_exists || return 1

md5="$(sqlite3 "select md5sum from TEMPLATES where \
  name='${OPT[TEMPLATE]}';")"

[[ -e "${OPT[TEMPLATE_DIR]}/${OPT[TEMPLATE]}.xml" ]] ||
  { sqlite3 "update TEMPLATES set md5sum='0',valid='0' \
      where name='${OPT[TEMPLATE]}';"; return 2; }

valid="$(sqlite3 "select valid from TEMPLATES where \
  name='${OPT[TEMPLATE]}';")"

check_rw "${OPT[TEMPLATE_DIR]}/${OPT[TEMPLATE]}.xml"
local md5_curr 
md5_curr="$(get_md5 "${OPT[TEMPLATE_DIR]}/${OPT[TEMPLATE]}.xml")"

[[ "$md5" == "$md5_curr" ]] && [[ "$valid" == "1" ]] && return 0
[[ "$md5" == "$md5_curr" ]] && [[ "$valid" == "0" ]] && return 2
[[ "$md5" == "$md5_curr" ]] && unexpected_error check_template

valid=0
virt-xml-validate "${OPT[TEMPLATE_DIR]}/${OPT[TEMPLATE]}.xml" \
  &>/dev/null && valid=1
sqlite3 "update TEMPLATES set md5sum='$md5_curr',valid='$valid' \
        where name='${OPT[TEMPLATE]}';"

local disks
if ((valid)); then
  get_disk_devices < "${OPT[TEMPLATE_DIR]}/${OPT[TEMPLATE]}.xml"
  disks="$(read_pipe)"
  sqlite3 "update TEMPLATES set disks='$disks',valid='$valid' \
        where name='${OPT[TEMPLATE]}';"
fi

((valid)) || return 2
return 0
}
#=========================================================================#
check_template_disks ()
# DESCRIPTION: Verify that the disks named by a template exist, can be read
#   and are not locked. This check is not needed for most commands, but
#   when it is needed, check_template should be succesfully run first to
#   verify that the disks column in the database is correct
# INPUT: None
# OUTPUT: Error messages and exit if needed
# PARAMETERS: None
#=========================================================================#
{
local disk qemu_out
while read -r disk; do
  [[ -e "$disk" ]] ||
    { echo "Template ${OPT[TEMPLATE]} refers to $disk, which either";
      echo "does not exist or cannot be seen with current permissions";
      exit "$E_template"; } >&2
  [[ -r "$disk" ]] ||
    { echo "Template ${OPT[TEMPLATE]} refers to $disk, but the file" ;
      echo "cannot be read";
      exit "$E_permission"; }
  qemu_out="$(qemu-img info "$disk" 2>&1)" ||
    { echo "When checking the disk file $disk with qemu-img, the";
      echo "following problem was encountered:";
      echo "$qemu_out";
      exit "$E_libvirt"; } >&2
done < <( sqlite3 "select disks from TEMPLATES where \
  name='${OPT[TEMPLATE]}';")

return 0
}
#=========================================================================#
check_template_exists ()
# DESCRIPTION: There are a few places where it is necessary to check that
#   a template exists, but not the rest of check_template, so this is its
#   own function
# INPUT: None
# OUTPUT: Return 0 if OPT[TEMPLATE] exists and 1 if it does not
# PARAMETERS: None
#=========================================================================#
{
local check
check="$(sqlite3 "select exists ( select * from TEMPLATES where\
  name='${OPT[TEMPLATE]}');")"
((check)) && return 0
return 1
}
#=========================================================================#
set_error ()
# DESCRIPTION: Used when convert_to_seq fails
# INPUT: None
# OUTPUT: Error message and exit
# PARAMETERS: None
#=========================================================================#
{
echo "Improper or badly formatted argument specifying machine or set of "
echo "machines"
exit "$E_args"
} >&2
#=========================================================================#
target_error ()
# DESCRIPTION: Used when intersection of user-specified set and set of
#   existing machines that are valid targets for current command results in
#   empty set
# INPUT: Name of command
# OUTPUT: Error message and exit
# PARAMETERS: $1: Name of command invoked with set
#=========================================================================#
{
echo "Specified set of machines does not contain any valid targets"
echo "for $1 to operate on"
exit "$E_args"
} >&2
#=========================================================================#
stage_error ()
# DESCRIPTION: When an action is attempted on a 'staging' clone, (one
#   created by modify-template prepare-image) but that clone is listed in
#   BAD_CL, this message is displayed
# INPUT: None
# OUTPUT: Error message and exit
# PARAMETERS: None
#=========================================================================#
{
echo "A clone staging changes to the template iamge was previously made,"
echo "but it is now missing. Restore it manually, connect to the"
echo "appropriate URI if it is on another connection, or delete it from" 
echo "qq2clone's database using the command:"
echo
echo "  qq2clone check ${OPT[TEMPLATE]}"
echo
echo "(This clone will have ID: 0)"
exit "$E_permission"
} >&2
#=========================================================================#
temp_error ()
# DESCRIPTION: If mktemp fails, this function should be invoked
# INPUT: None
# OUTPUT: Error message and exit with E_extcom
# PARAMETERS: None
#=========================================================================#
{
echo "Attempt to create a temp file with mktemp failed"
exit "$E_extcom"
} >&2
#=========================================================================#
template_error ()
# DESCRIPTION: Takes a return code from check_template, gives appropriate
#   error message and exits if it is nonzero
# INPUT: Check_template return status
# OUTPUT: Error message and exit code or nothing
# PARAMETERS: $1: Return code from check_template
#=========================================================================#
{
(($1 == 1)) &&
  { echo "The template '${OPT[TEMPLATE]}' does not exist";
    exit "$E_template"; }
(($1 == 2)) &&
  { echo "The template '${OPT[TEMPLATE]}' is not valid due to bad";
    echo -n "or missing XML at location:";
    echo
    echo "  ${OPT[TEMPLATE_DIR]}/${OPT[TEMPLATE]}.xml";
    echo
    exit "$E_template"; }
return 0
} >&2
#=========================================================================#
template_name_available ()
# DESCRIPTION: Check that the template name is available, and give an
#   appropriate error message if not
# INPUT: A name
# OUTPUT: An error message if needed
# PARAMETERS: $1: Template name to check
#=========================================================================#
{
local name
while IFS= read -r name; do
  if [[ "$name" == "$1" ]]; then
    echo "The name $1 belongs to an existing template"
    exit "$E_template"
  fi
done < <(sqlite3 "select name from TEMPLATES;")
if [[ -e "${OPT[TEMPLATE_DIR]}/${1}.xml" ]]; then
  echo "Although template name $1 is not currently in use,"
  echo "a file where this template's XML document belongs already"
  echo "exists. Move or delete this file:"
  echo  
  echo "  ${OPT[TEMPLATE_DIR]}/${1}.xml"
  exit "$E_template"
fi
return 0
} >&2
#=========================================================================#
unexpected_error ()
# DESCRIPTION: Error on unexpected event, which is likely a bug in qq2clone
# INPUT: None
# OUTPUT: Error message and exit code
# PARAMETERS: $1: function name where error occurred
#=========================================================================#
{
echo "qq2clone has encountered an unexpected problem."
echo "The problem occurred in function: $1"
exit "$E_unexpected"
} >&2
#=========================================================================#
valid_xml_name_check ()
# DESCRIPTION: Check that XML is valid after modifying name and return 0 
#   if so, exit with error message else
# INPUT: write_piped XML file and new name as parameter. Leaves XML in
#   pipe after execution
# OUTPUT: Error message and exit code if needed
# PARAMETERS: $1: The new name
#=========================================================================#
{
virt-xml --edit --metadata name="$1"<<<"$(read_pipe 1)" &>/dev/null ||
  { echo "When trying to use name $1 to generate an xml"
    echo "file, there was an error - this name is not acceptable"
    echo "for a libvirt domain. Try another."
    exit "$E_libvirt" ; } >&2
} >&2

                     #--------------------------------#
                     #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
                     #---HELPERS FOR EXEC_COM_CHECK---#
                     #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
                     #--------------------------------#

#=========================================================================#
delete_template_and_clones ()
# DESCRIPTION: Delete a template and all of its clones
# INPUT: None
# OUTPUT: Status updates
# PARAMETERS: None
#=========================================================================#
{
echo
hr
echo
echo "DELETING TEMPLATE: ${OPT[TEMPLATE]}"
local id disk
echo
local fail=0
echo " Deleting all defined clone domains"
for id in "${!CL_MAP[@]}"; do
  echo " Attempting to delete ${OPT[TEMPLATE]}#${id} ${CL_MAP["$id"]}..."
  if ( delete_machine "$id" ) &> /dev/null; then
    echo "  Success."
  else
    echo "  Failed."
    fail=1
  fi
done
if ((fail)) || (( ${#BAD_CL[@]} )); then
  echo
  echo "  Manually deleting files and/or undefining any remaining domains"
  while read -r id; do
    while read -r disk; do
      [[ -z "$disk" ]] && continue
      rm -f "$disk" &>/dev/null ||
      [[ -e "$disk" ]] &&
        { echo "Failed to delete $disk, check permissions. Aborting" >&2;
          exit "$E_permission"; }
    done < <(sqlite3 "select disks from CLONES where id='$id' and \
      template='${OPT[TEMPLATE]}'")
    sqlite3 "delete from CLONES where id='$id' and \
      template='${OPT[TEMPLATE]}';"
      echo "  Deleted ${OPT[TEMPLATE]}#${id} ${CL_MAP["$id"]}"
  done < <(sqlite3 "select id from CLONES where \
    template='${OPT[TEMPLATE]}';")
fi
echo
echo "  All clones deleted."
echo
rm -f "${OPT[TEMPLATE_DIR]}/${OPT[TEMPLATE]}.xml" &>/dev/null 
if [[ -e "${OPT[TEMPLATE_DIR]}/${OPT[TEMPLATE]}.xml" ]]; then
  echo "Failed to delete template XML at" >&2
  echo "${OPT[TEMPLATE_DIR]}/${OPT[TEMPLATE]}.xml" >&2
  echo "Aborting"
  exit "$E_permission"
fi
sqlite3 "delete from TEMPLATES where name='${OPT[TEMPLATE]}';"
echo "TEMPLATE DELETED: Template ${OPT[TEMPLATE]} deleted."
return 0
}
#=========================================================================#
prompt_delete_bad_clones ()
# DESCRIPTION: Iterate through missing clones, prompting user before 
#   taking action
# INPUT: None
# OUTPUT: Prompts and status updates to user
# PARAMETERS: None
#=========================================================================#
{
local id i=0 total="${#BAD_CL[@]}" disk prompt=1 select 
local t="${OPT[TEMPLATE]}"
for id in "${!BAD_CL[@]}"; do
  ((i++))
  echo
  hr
  echo
  echo "MISSING CLONE ${i} / $total"
  echo "  ID: $id"
  echo "UUID: ${BAD_CL["$id"]}"
  while read -r disk; do
    echo "DISK: $disk"
  done < <(sqlite3 "select disks from CLONES where id='$id' and\
    template='${t}';")
  echo
  if ((prompt)); then
    echo "  (1) Delete clone from database, DO NOT delete disk files"
    echo "  (2) Delete clone from database, DO delete disk files"
    echo "  (3) Skip this clone"
    echo "  (4) Do option (1) for all missing clones of this template"
    echo "  (5) Do option (2) for all missing clones of this template"
    echo "  (6) Abort: leave the clones as they are"
    select="$(prompt_num 1 6)"
    (( select == 6 )) && { echo "Abort"; return 0; }
    (( select == 5 )) && { select=2; prompt=0; }
    (( select == 4 )) && { select=1; prompt=0; }
    (( select == 3 )) && { echo "Skipping"; echo; continue; }
  fi
  echo
  if ((select==2)); then
    while read -r disk; do
      [[ -e "$disk" ]] ||
        { echo "  $disk :"
          echo "    Already deleted or has been moved"
          continue; }
      if rm -f "$disk" &>/dev/null; then
        echo "  Deleted $disk"
      else
        echo "  Failed to delete $disk"
      fi
    done < <(sqlite3 "select disks from CLONES where id='$id' and\
      template='${t}';")
  fi
  sqlite3 "delete from CLONES where id='$id' and template='$t';"
  echo "  Clone deleted from database"
  echo
done
return 0
}
#=========================================================================#
prompt_delete_orphans ()
# DESCRIPTION: Find any image files in qq2clone's default storage directory
#   that don't belong to qqclone2 or any machine on the current libvirt
#   connetion
# INPUT: None
# OUTPUT: Prompts user and gives status updates
# PARAMETERS: None
#=========================================================================#
{
# This function is very long, partially due to lots of echo statements
# and requests for user input. However, all of the text describing things
# to the user also makes it easy to understand the code, so for now 
# I am leaving it as-is.
hr
echo
echo "qq2clone will look in its default storage pool:" 
echo
echo "  ${OPT[STORAGE]}"
echo
echo "Any files found there that are not storage devices in use by"
echo "a virtual machine on the current libvirt connection or qq2clone"
echo "templates will be considered orphans. This shouldn't take too long,"
echo "but it could if you have a lot of files in that location, a large"
echo "number of domains defined, or a slow machine"
echo
echo "qq2clone will take no action on these files unless directed to"
echo
echo "Ctrl+C to abort search"
echo
hr
echo
local patt
patt="^[[:space:]]*[^[:space:]]+[[:space:]]+([^[:space:]].*[^[:space:]])"
patt="${patt}[[:space:]]*$"

local check
check="$(virsh list --all)"
check="$(strip_ws "$check")"
if [[ -n "$check" ]]; then check=1; else check=0; fi

local uuid device path c=8 n match

echo "Generating list of domain storage devices..."
while (( check )) && read -r device; do
  while (( c )); do (( c-- )); continue 2; done;

  if [[ -z "$device" ]]; then
    for ((c=3;c>0;)); do
      read -r n; [[ -z "$n" ]] && continue
      (( c-- ))
    done
    continue
  fi
  [[ "$device" =~ $patt ]] && write_pipe 0 "${BASH_REMATCH[1]}"

done < <( while read -r uuid; do \
  echo "domblklist $uuid; echo --err null;\
  domblklist $uuid --inactive;"; done \
    < <( virsh list --all --uuid ) | virsh 2>&1 )

# We have all the disk files associated with domains, but we still need
# the ones referenced by template XML
declare -a templates
while read -r line; do
  write_pipe 0 "$line"
done < <(sqlite3 "select disks from TEMPLATES;")

echo "Generating list of filepaths in default storage pool..."
declare -a f_paths
local path
while read -r path; do
  f_paths[${#f_paths[@]}]="$path"
done < <(find "${OPT[STORAGE]}" -depth -mindepth 1 2>/dev/null)

echo "Comparing..."
declare -a orphans
match=0
for path in "${f_paths[@]}"; do
  while read -r device; do
    (( match )) && continue
    if [[ "$device" == "$path" ]]; then
      match=1
    fi
  done < <( read_pipe 1 )
  [[ "$match" == "1" ]] && { match=0; continue; }
  orphans[${#orphans[@]}]="$path"
done 
read_pipe >/dev/null

local j=${#orphans[@]}
if ((j)); then
  echo
  echo "Total potentially orphaned files: $j"
  echo
  echo "Remember that false positives are very possible. qq2clone"
  echo "considers any file in its default storage pool that is not"
  echo "a storage device for a virtual machine listed by virsh or"
  echo "a template known to qq2clone to be an orphan. It is unwise to"
  echo "delete any detected files without looking at them first"
  echo
  prompt_yes_no && less \
    < <( for path in "${orphans[@]}"; do echo "$path"; done  )
  echo
  echo "Would you like to store a copy of this list to disk?"
  local temp
  if prompt_yes_no; then
    temp="$(mktemp)"
    for path in "${orphans[@]}"; do echo "$path"; done > "$temp"
    echo "File printed to $temp"
  fi
  echo
  echo "1) Delete all files found"
  echo "2) Answer a prompt to delete or leave alone each file"
  echo "3) Abort and handle the situation manually"
  local select prompt=1 file fail=0
  select="$(prompt_num 1 3)"
  ((select==1)) && prompt=0
  ((select==3)) && { echo "Abort"; return 0; }

 local i
  for ((i=0;i<j;i++));do
    hr
    file="${orphans["$i"]}"
    echo "$file"
    echo "  $((i+1))/$j"
    echo "  Type: $(file "$file")"
    if ((prompt)); then
      echo "  1) Delete it"
      echo "  2) Leave it alone"
      echo "  3) Delete all"
      echo "  4) Abort"
      select="$(prompt_num 1 4)"
      ((select==2)) && continue
      ((select==3)) && prompt=0
      ((select==4)) && { echo "Abort"; return 0; }
    fi
    chmod +rw "$file" &>/dev/null
    rmdir "$file" &>/dev/null
    rm -f "$file" &>/dev/null
    if [[ -e "$file" ]]; then
      echo "Unable to delete"
      write_pipe "$file"
      fail=1
    else
      echo "Deleted"
    fi
    echo
  done
  if ((fail)); then
    echo "Check complete, but failed to delete some files."
    echo
    echo "View a list of fails qq2clone failed to delete?"
    if prompt_yes_no; then
      echo
      read_pipe 1 | less
    else
      echo
    fi
    echo "Save to disk?"
    if prompt_yes_no; then
      echo
      temp="$(mktemp)"
      read_pipe > "$temp"
      echo "File printed to $temp"
    else
      echo
    fi
  else
    echo "Orphaned file check completed"
  fi
else
  echo
  echo "No orphaned files were found"
fi
return 0
}

                      #-----------------------------#
                      #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
                      #---INTERACT WITH VIRSH/VMs---#
                      #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
                      #-----------------------------#
                     
#=========================================================================#
clone ()
# DESCRIPTION: Clone a virtual machine from OPT[TEMPLATE]
# INPUT: If desired, designate that clone should have special ID 0
# OUTPUT: Echo message when complete or on error
# PARAMETERS: $1: (Optional) If '0', create clone intended for staging 
#   changes to a base template image
#=========================================================================#
{ 
local base_mach_name line check i
local txml="${OPT[TEMPLATE_DIR]}/${OPT[TEMPLATE]}.xml"

if [[ "$1" == "0" ]]; then
  # ID reserved for clone where changes to template image are staged
  i="0"
  check="$(sqlite3 "select exists ( select * from CLONES where id='0' and \
    template='${OPT[TEMPLATE]}');")"
  ((check)) && return 1
  base_mach_name="${OPT[TEMPLATE]}#STAGING"
else
  for((i=1;;i++)); do
  check="$(sqlite3 "select exists ( select * from CLONES where id='$i' \
    and template='${OPT[TEMPLATE]}');")"
    (("$check")) || break
  done
  base_mach_name="${OPT[TEMPLATE]}#${i}"
fi

local name uuid
{
  read -r name
  read -r uuid
} < <(unique_name_uuid 2 "$base_mach_name")


local storage="${OPT[STORAGE]}"
declare -a f_arr
local img new_img j=-1 type level

local disks
disks="$(sqlite3 "select disks from TEMPLATES where\
  name='${OPT[TEMPLATE]}';")"

trap 'rm -f "${storage}/${name}.${uuid:?}.*"' INT
while read -r img; do
  ((j++))
  new_img="${storage}/${name}.${uuid}.${j}.qcow2"
  level=0
  while read -r line; do
    [[ "$line" =~ \{[[:space:]]*$ ]] && { ((level++)); continue; }
    [[ "$line" =~ \},?[[:space:]]*$ ]] && { ((level--)); continue; }
    if ((level == 1)); then
      [[ "$line" =~ \"format\":[[:space:]]*\"(.*)\" ]] &&
        type="${BASH_REMATCH[1]}"
    fi
  done < <(qemu-img info --output=json "$img")
  qemu-img create -f qcow2 -F "$type" -b "$img" "$new_img"\
    &>/dev/null ||
      { rm -f "${storage}/${name}.${uuid:?}.*";
        unexpected_error clone; }
  f_arr[${#f_arr[@]}]="-f"
  f_arr[${#f_arr[@]}]="$new_img"
done < <(echo "$disks")


virt-clone --original-xml "$txml" --name "$name" --uuid "$uuid"\
    --preserve-data "${f_arr[@]}" &>/dev/null ||
      { rm -f "${storage}/${name}.${uuid:?}.*";
        unexpected_error clone; }

disks=""
local before=0
for ((j=1;j<${#f_arr[@]};j+=2)); do
  if ((before)); then
    disks="$(echo "$disks";echo "${f_arr["$j"]}")"
  else
    before=1
    disks="${f_arr["$j"]}"
  fi
done

sqlite3 "insert into CLONES values \
  ('$uuid','$i','${OPT[TEMPLATE]}','$disks');"

((OPT[QUIET])) || echo "Cloned: $name $uuid"

CL_MAP["$i"]="$uuid"
CL_STATE["$i"]="off"

trap 'exit' INT
if (( OPT[NORUN] )); then
  return 0
elif ((OPT[USE_SPICE])); then
  connect "$i"
else
  start_domain "$i"
fi

return 0
}
#=========================================================================#
connect ()
# DESCRIPTION: Run machine. If it has spice graphics, connect to graphical
#   console with virt-viewer/spicy
# INPUT: Machine number
# OUTPUT: None except on error
# PARAMETERS: $1: Machine number
#=========================================================================#
{
if (( OPT[SPICY] )); then
  command -v spicy &> /dev/null ||
    { echo "Cannot find command spicy" >&2; exit "$E_extcom"; }
else
  command -v virt-viewer &> /dev/null ||
      { echo "Cannot find command virt-viewer" >&2; exit "$E_extcom"; }
fi

start_domain "$1"

local uuid
uuid="${CL_MAP["$1"]}"
has_spice "$1" || return 0

local spice
read -ra spice < <(get_spice "$1") ||
  { echo "Machine did not become available before timeout" >&2;
    exit "$E_timeout"; }
(( $1 == 0 )) && set -- "STAGING"
if (( OPT[SPICY] )); then
  command -v spicy &> /dev/null ||
    { echo "Cannot find command spicy" >&2; exit "$E_extcom"; }
  nohup spicy --title "${OPT[TEMPLATE]}#$1" -h "${spice[0]}" \
    -p "${spice[1]}" &>/dev/null &
else
  command -v virt-viewer &> /dev/null ||
      { echo "Cannot find command virt-viewer" >&2; exit "$E_extcom"; }
  nohup virt-viewer --uuid "$uuid" &>/dev/null &
fi

return 0
}
#=========================================================================#
delete_machine ()
# DESCRIPTION: Delete a clone 
# INPUT: Machine number
# OUTPUT: None
# PARAMETERS: $1: machine number, $2: 0 to just delete disks, 1 to wipe, 2
#   to shred
#=========================================================================#
{
local uuid
uuid="${CL_MAP["$1"]}"

local line disks before=0
while read -r line; do
  ((before)) && disks="${disks},"; before=1
  disks="${disks}$line"
done < <(sqlite3 "select disks from CLONES where id='$1' and\
  template='${OPT[TEMPLATE]}';")

declare -a undef_args
undef_args=( '--managed-save' '--snapshots-metadata' '--nvram' \
  '--checkpoints-metadata' )
if (( $2 < 2 )); then 
  undef_args=( "${undef_args[@]}" '--storage' "$disks")
fi
if (($2==1)); then 
  undef_args=( "${undef_args[@]}" "--wipe-storage" )
fi

destroy_domain "$1" &>/dev/null

if (( $2 == 2 )); then
  local disk
  echo "Shredding ${OPT[TEMPLATE]}#$1 disks..."
  while read -r disk; do
    {
    cd "$(dirname "$disk")" &&
    { shred -vf "$(basename "$disk")" 2>&1 | sed "s/^./  &/"; } &&
      rm -f "$disk" &>/dev/null 
    } || unexpected_error delete_machine
  done  < <(sqlite3 "select disks from CLONES where id='$1' and\
    template='${OPT[TEMPLATE]}';")
fi

local virsh_out
virsh_out="$(virsh undefine  "$uuid" "${undef_args[@]}" 2>&1)" ||
  { echo "$virsh_out"; unexpected_error delete_machine; }
  
sqlite3 "delete from CLONES where id='$1' and \
  template='${OPT[TEMPLATE]}';"

return 0
}
#=========================================================================#
destroy_domain ()
# DESCRIPTION: Invoke virsh destroy on given machine
# INPUT: A machine number
# OUTPUT: None
# PARAMETERS: A machine number
#=========================================================================#
{
local uuid
uuid="${CL_MAP["$1"]}"
virsh destroy "$uuid" &>/dev/null
return 0
}
#=========================================================================#
discard_save ()
# DESCRIPTION: Delete a saved state file associated with a clone
# INPUT: A saved machine number
# OUTPUT: Error message, exit code if needed
# PARAMETERS: $1: A saved machine number
#=========================================================================#
{
local virsh_out
virsh_out="$(virsh managedsave-remove "${CL_MAP["$1"]}" 2>&1)" ||
  { echo "$virsh_out"; exit "${E_libvirt}"; }
return 0
}
#=========================================================================#
edit_xml ()
# DESCRIPTION: Edit and verify OPT[TEMPLATE]'s XML file
# INPUT: None
# OUTPUT: Status updates to user, error messages as needed
# PARAMETERS: None
#=========================================================================#
{
local xml="${OPT[TEMPLATE_DIR]}/${OPT[TEMPLATE]}.xml"
[[ -e "$xml" ]] ||
  { echo "The template XML is missing from $xml"
    echo "There is nothing to edit."
    exit "$E_template"; } >&2

check_template_exists || template_error $?
    
local temp
temp="$(mktemp)" || temp_error
trap 'rm -f "$temp" &>/dev/null;' INT

local ed_com="vi"
[[ -n "$EDITOR" ]] && ed_com="$EDITOR"
[[ -n "$VISUAL" ]] && ed_com="$VISUAL"

local md5_curr md5_old
md5_old="$(get_md5 "$xml")"

copy_file "$xml" "$temp"

local loop=1
while ((loop)); do
  "$ed_com" "$temp" || 
    { echo "Editing XML with $ed_com failed" >&2;
      rm -f "$temp" &>/dev/null;
      exit "$E_extcom"; }
  md5_curr="$(get_md5 "$temp")"
  [[ "$md5_old"  == "$md5_curr" ]] &&
    { ((OPT[QUIET])) || echo "No changes made to original XML";
      rm "$temp";
      exit 0; }

  local virt_message=""
  if virt_message="$(virt-xml-validate "$temp" 2>&1)"; then
    loop=0
  else
    echo >&2
    echo "$virt_message" >&2
    echo "Changes resulted in malformed XML file. " >&2
    prompt_yes_abort \
      "Press (e) to edit again, anything else to abort and revert" \
      "^[Ee]$" >&2 || { rm "$temp" &>/dev/null; exit "$E_xml"; }  
  fi
done
move_file "$temp" "$xml" 
check_template

((OPT[QUIET])) || echo "XML modified"
trap 'exit' INT

return 0
}
#=========================================================================#
get_template_list ()
# DESCRIPTION: List existing templates, alphabetically ordered, one per 
#  line
# INPUT: None
# OUTPUT: List of templates
# PARAMETERS: None
#=========================================================================#
{
sqlite3 "select name from TEMPLATES;" | sort
return 0
}
#=========================================================================#
get_spice ()
# DESCRIPTION: Get the spice host and port of a running machine
# INPUT: The machine number
# OUTPUT: Echoes '$hostname $port' pertaining to spice connection
# PARAMETERS: $1: The machine number
#=========================================================================#
{
local uuid time line spice state
time="$(date +%s)"
uuid="${CL_MAP["$1"]}"
until (( OPT[S_TIMEOUT] <= $(date +%s)-time )) ; do
  spice="$(virsh domdisplay --type spice "$uuid" 2>&1)"
  [[ "$spice" =~ ^'spice://'(.+):(.+)$ ]] || continue
  echo "${BASH_REMATCH[1]} ${BASH_REMATCH[2]}"; 
  return 0;
done
return 1
}
#=========================================================================#
get_state ()
# DESCRIPTION: Get the state of a machine by number
# INPUT: The number of a clone managed by qq2clone
# OUTPUT: Echoes the state of the machine
# PARAMETERS: $1: Machine number
#=========================================================================#
{
echo "${CL_STATE["$1"]}"
return 0
}
#=========================================================================#
get_state_set () 
# DESCRIPTION: List all machines in a given state
# INPUT: Name of a state
# OUTPUT: Echoes a space delimited list of machine numbers (can be empty)
# PARAMETERS: $1: state name
#=========================================================================#
{
local id before=0 state
while read -r id; do
    state="$(get_state "$id" )"
    if [[ "$state" == "$1" ]] || [[ "$1" == "all" ]]; then
      [[ "$id" == "0" ]] && continue
      ((before)) && echo -n " "; before=1
      echo -n "$id "
    fi
done < <(echo "${!CL_MAP[@]}" | tr " " "\n")
echo
return 0
}
#=========================================================================#
get_target_set ()
# DESCRIPTION: Get the set of all machines that a command may legally
#   operate on
# INPUT: A command name
# OUTPUT: Echoes a space delimited set of machine numbers (can be empty)
# PARAMETERS: $1: The command name
#=========================================================================#
{
local id before=0 statelist state
statelist="$(list_states "$1")"
while read -r id; do
  state="$(get_state "$id" )"
  if [[ "$statelist" =~ all ]] || [[ "$statelist" =~ $state ]] ; then
    [[ "$id" == "0" ]] && continue
    ((before)) && echo -n " "; before=1
    echo -n "$id"
  fi
done < <(echo "${!CL_MAP[@]}" | tr " " "\n")
echo
return 0
}
#=========================================================================#
list_display ()
# DESCRIPTION: Display list of clones and their state to user
# INPUT: Optionally, pass argument "1" to print detailed xml list
# OUTPUT: Clone list
# PARAMETERS: $1: Set to one to print xml summary instead of a regular 
#   list
#=========================================================================#
{
declare -A statelist
local line state

if [[ -n "${CL_MAP[0]}" ]]; then
  statelist["${CL_STATE[0]}"]="0"
fi

while read -r line; do
  [[ -z "$line" ]] && continue
  state="$(get_state "$line")"
  if [[ -n "${statelist["$state"]}" ]]; then
    statelist["$state"]="${statelist["$state"]} $line"
  else
    statelist["$state"]="$line"
  fi
done < <(get_state_set all | tr " " "\n")

declare -a states machines
read -ra states \
      < <(echo "${!statelist[@]}" |tr " " "\n" | sort | tr "\n" " ")
local state m
if (($1)); then
#shellcheck disable=2119
# This is only a (functioning) mock implementation meant as a proof of 
# concept for what XML describing qq2clone's current state may be like.
# For this feature to be complete, it would: use a defined format, be 
# implemented with proper, modular code, and contain all information to
# fully define qq2clone's state except for machine images and domain xml.
  echo "  <template name=\"${OPT[TEMPLATE]}\">"
  local disk
  get_disk_devices_db
  while read -r disk; do
    echo "    <disk>${disk}</disk>"
  done < <(read_pipe)
  echo "    <xml>${OPT[TEMPLATE_DIR]}/${OPT[TEMPLATE]}.xml</xml>"
  local uuid
  for state in "${states[@]}"; do
    echo "    <cloneset state=\"$state\">"
    read -ra machines <<<"${statelist["$state"]}"
    for m in "${machines[@]}" ; do
      echo -n "      <clone id=\"$m\" "
      echo -n "name=\"${NAME_MAP["$m"]}\" "
      uuid="${CL_MAP["$m"]}"
      echo "uuid=\"$uuid\">"
      get_disk_devices_db "$m"
      while read -r disk; do
        echo "        <disk>${disk}</disk>"
      done < <(read_pipe)
      echo "      </clone>"
    done
    echo "    </cloneset>"
  done
  local id
  if ((${#BAD_CL[@]})); then
    echo "    <cloneset state=\"missing\">"
    for id in "${!BAD_CL[@]}"; do
      echo "    <clone id=\"$id\" uuid=\"${BAD_CL["$id"]}\">"
      get_disk_devices_db "$id"
      while read -r disk; do
        echo "        <disk>${disk}</disk>"
      done < <(read_pipe)
      echo "    </clone>"
    done
    echo "    </cloneset>"
  fi
  echo "  </template>"
else
  echo "[${OPT[TEMPLATE]}]";
  if [[ -z "${statelist[*]}" ]]; then
    echo "  No clones"
  else
    for state in "${states[@]}"; do
      read -ra machines <<<"$(strip_ws "${statelist["$state"]}")"
      echo -n "  ${state}: ";
      for elem_mach in "${machines[@]}"; do
        (( elem_mach )) || { echo -n "[#0: STAGING] "; continue; }
        echo -n "#$elem_mach "
      done
      echo
    done
  fi
fi
return 0
}
#=========================================================================#
list_states ()
# DESCRIPTION: Helper for get_target_set. Lists machine states that a
#   given command can act on. States are the same as listed in man virsh,
#   but "shut off" is "off", "in shutdown" is "in-shutdown", "saved" is 
#   added, and "all" addresses machines in any state
# INPUT: The command name
# OUTPUT: Echoes a space delimited list of states
# PARAMETERS: $1: The command name, or if no arguments list all states
#   as a space delimited list
#=========================================================================#
{
if (($#)); then
  if [[ "$1" == connect ]]; then
    echo "all"
  elif [[ "$1" == destroy ]]; then                    
    echo "running idle paused in-shutdown pmsuspended"
  elif [[ "$1" == exec ]]; then
    echo "all"
  elif [[ "$1" == restore ]]; then                    
    echo "saved"                                      
  elif [[ "$1" == resume ]]; then                     
    echo "paused"                                     
  elif [[ "$1" == rm ]]; then
    echo "all"
  elif [[ "$1" == rm-wipe ]]; then
    echo "all"
  elif [[ "$1" == rm-shred ]]; then
    echo "all"
  elif [[ "$1" == save ]]; then                         
    echo "running pmsuspended idle paused paused"
  elif [[ "$1" == save-rm ]]; then
    echo "saved"
  elif [[ "$1" == start ]]; then                      
    echo "off crashed saved"
  elif [[ "$1" == suspend ]]; then                    
    echo "running pmsuspended idle"                  
  fi
else
  echo -n "all crashed idle in-shutdown off paused pmsuspended running"
  echo " saved"
fi
}
#=========================================================================#
load_template ()
# DESCRIPTION: Run check_template, build global arrays CL_MAP[ID]=UUID,
#   CL_STATE[ID]=STATE, and BAD_CL[ID]=UUID
# INPUT: None
# OUTPUT: None
# PARAMETERS: None
#=========================================================================#
{
# This is a hacky way of getting the information we need in a reasonably 
# performant manner. It is a bit fragile, but not overly so assuming that
# virsh's output is fairly consistent across versions. This method is
# temporary, as later on qq2clone will include portions in (probably) C 
# that use the libvirt API instead of virsh

check_template
unset BAD_CL CL_MAP CL_STATE NAME_MAP
declare -ga BAD_CL CL_MAP CL_STATE NAME_MAP

local t="${OPT[TEMPLATE]}"

local check
check="$(sqlite3 "select exists ( select id,uuid from CLONES where \
          template='${OPT[TEMPLATE]}' );")"
((check)) || return 0

# Build array of all UUIDs -> IDs for template's clones
declare -A uuid_map
local id uuid
while read -r id; do
  read -r uuid
  uuid_map["$uuid"]="$id"
done < <(sqlite3 "select id,uuid from CLONES where template='$t';")

# To use virsh in shell mode without having to repeatedly invoke it in
# different subshells for a large performance penalty, we will run it in
# the background and write to it with one fifo while reading it from 
# another
local temp
temp="$(mktemp -d)" || temp_error
mkfifo "$temp/fifo" &>/dev/null || unexpected_error load_template
exec 4<>"$temp/fifo"
virsh <&3 >&4 2>&4 &
# virsh prepends 5 lines of useless output
local c; for ((c=5;c>0;c--)); do read -r <&4; done

local prompt="virsh #" # In the virsh shell, input lines start with this

  echo "list --all --uuid" >&3
  echo "echo EOF" >&3
  while read -r uuid <&4; do
    { [[ "$uuid" =~ ^$prompt ]] || [[ -z "$uuid" ]] ; } && continue
    [[ "$uuid" == "EOF" ]] && break
    
    [[ -n "${uuid_map["$uuid"]}" ]] && 
      CL_MAP["${uuid_map["$uuid"]}"]="$uuid"
  done
  
local match _uuid
for uuid in "${!uuid_map[@]}"; do
  match=0
  for _uuid in "${CL_MAP[@]}"; do
    [[ "$uuid" == "$_uuid" ]] && { match=1; break; }
  done
  ((match)) && continue
  BAD_CL["${uuid_map["$uuid"]}"]="$uuid"
done

local line
for id in "${!CL_MAP[@]}"; do
  uuid="${CL_MAP["$id"]}"
  echo "domstate $uuid" >&3
  echo "echo EOF" >&3
  while read -r line <&4; do
  { [[ "$line" =~ ^$prompt ]] || [[ -z "$line" ]] ; } && continue
  [[ "$line" == "EOF" ]] && break
    [[ "$line" == "in shutdown" ]] && line="in-shutdown"
    [[ "$line" == "shut off" ]] && line="off"
    CL_STATE["$id"]="$line"
  done
  
  echo "domname $uuid" >&3
  echo "echo EOF" >&3
  while read -r line <&4; do
  { [[ "$line" =~ ^$prompt ]] || [[ -z "$line" ]] ; } && continue
  [[ "$line" == "EOF" ]] && break
    NAME_MAP["$id"]="$line"
  done
done

echo "list --all --uuid --with-managed-save" >&3
echo "echo EOF" >&3

while read -r uuid <&4; do
  { [[ "$uuid" =~ ^$prompt ]] || [[ -z "$uuid" ]] ; } && continue
  [[ "$uuid" == "EOF" ]] && break
  id="${uuid_map["$uuid"]}"
  [[ -z "$id" ]] && continue;  [[ -z "${CL_MAP["$id"]}" ]] && continue;
  CL_STATE["$id"]="saved"
done

echo "quit" >&3
exec 4>&-
exec 4<&-
rm -rf "$temp" &>/dev/null

return 0
}
#=========================================================================#
save_domain ()
# DESCRIPTION: Save the state of a machine to disk
# INPUT: Machine number
# OUTPUT: None
# PARAMETERS: $1: Machine number
#=========================================================================#
{
local uuid 
uuid="${CL_MAP["$1"]}"
virsh managedsave "$uuid" &>/dev/null
return 0
}
#=========================================================================#
start_domain ()
# DESCRIPTION: If a domain is not running, start it
# INPUT: VM number or "staging"
# OUTPUT: None, except on error. Returns 0 if machine is running
# PARAMETERS: $1: Machine number
#=========================================================================#
{

local state uuid
uuid="${CL_MAP["$1"]}"

state="$(get_state "$1")"

if [[ "$state" =~ ^(off|crashed|saved)$ ]]; then
  virsh start "$uuid" >/dev/null  ||
    { echo "Virsh failed to start domain" >&2;
      exit "$E_libvirt"; }
elif [[ "$state" == "paused" ]]; then
  virsh resume "$uuid" >/dev/null ||
    { echo "Virsh failed to resume domain" >&2;
      exit "$E_libvirt"; }
fi

return 0
}
#=========================================================================#
suspend_domain ()
# DESCRIPTION: Suspend execution state of machine
# INPUT: A machine number
# OUTPUT: None
# PARAMETERS: $1: A machine number
#=========================================================================#
{
local uuid
uuid="${CL_MAP["$1"]}"
virsh suspend "$uuid" &>/dev/null
}
#=========================================================================#
unique_name_uuid ()
# DESCRIPTION: Generate a name and/or uuid unique within libvirt connection
# INPUT: Choice of uuid, name or both, and base machine name if requesting
#   name
# OUTPUT: Echo name and uuid in that order, on separate lines
# PARAMETERS: $1: 0 for name only, 1 for uuid only, or 2 for both
#   $2: Base machine name (required unless $1 is 1)
#=========================================================================#
{ # TODO there is no reason for this to be one function
local name="$2" uuid loop line unique list

if (($1 != 1)); then
  RANDOM=$$
  list="$(virsh list --all --name)"
  unique=0
  until ((unique)); do
    while read -r line; do
      [[ -z "$line" ]] && continue
      if [[ "$line" == "$name" ]]; then
        name="${2}___${RANDOM}"
        continue 2
      fi
    done < <(echo "$list")
    unique=1
  done
  echo "$name"
fi

if (($1 != 0)); then
  list="$(virsh list --all --uuid)"
  list="${list}$(echo;ls -1 "${OPT[STORAGE]}")"
  unique=0
  uuid="$(uuidgen -r)"
  until ((unique)); do
    while read -r line; do
      [[ -z "$line" ]] && continue
      if [[ "$line" =~ .*"$uuid".* ]]; then
        uuid="$(uuidgen -r)"
        continue 2
      fi
    done < <(echo "$list")
    unique=1
  done
  echo "$uuid"
fi

return 0
}

              #---------------------------------------------#
              #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
              #---PARSE COMMAND STRING AND INVOKE COMMAND---#
              #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@#
              #---------------------------------------------#

# Generally, user input should be checked in this section. When functions
# from other sections omit testing that user-defined values are valid,
# this is why

#=========================================================================#
convert_to_seq ()
# DESCRIPTION: Take a set of the format described in the man page and echo
#   it as an ordered ascending, space delimited sequence of valid machine
#   numbers
# INPUT: A set
# OUTPUT: A sequence of numbers. Returns 1 if bad set
# PARAMETERS: $1: A set
#=========================================================================#
{
local s="$1"

{ [[ "$1" =~ ^[,-] ]] || [[ "$1" =~ [,-'^']$ ]] ||
  [[ "$1" =~ [,-][,-] ]] || [[ "$1" =~ [[:space:]] ]] ||
  [[ "$1" =~ ^.(.*[^',']\^) ]]; } && return 1

declare -a parts
IFS="," read -ra parts <<<"$s"
local states i p not LH RH minus plus
states="$(list_states| tr " " "|")"

for ((i=0;i<${#parts[@]};i++)); do
  p="${parts["$i"]}"
  not=0
  if [[ "${p:0:1}" == "^" ]]; then
    p="${p:1}"
    not=1
  fi
  
  if [[ "$p" =~ ^${states}$ ]]; then
    p="$(get_state_set "$p")"
  elif [[ "$p" =~ ^([0-9]+)'-'([0-9]+)$ ]]; then
    LH="${BASH_REMATCH[1]}"; RH="${BASH_REMATCH[2]}";
    ((RH>LH)) || return 1
    ((LH>0)) || return 1
    for ((p=LH;LH<RH;LH++)); do
      p="$p $((LH+1))"
    done
  elif [[ "$p" =~ ^[0-9]+$ ]]; then
    ((p>0)) || return 1
  else
    return 1
  fi
  
  if ((not)); then  
    minus=" $minus $p "
  else
    plus="$plus $p"
  fi
done
[[ "$plus $minus" =~ [^0-9' '] ]] && return 1

local n before=0
while read -r n; do
  [[ -z "$n" ]] && continue
  [[ "$minus" =~ [[:space:]]${n}[[:space:]] ]] && continue
  ((before)) && echo -n " "; before=1
  echo -n "$n"
done < <( tr " " "\n" <<<"$plus" | sort -n | uniq )
echo

return 0
}
#=========================================================================#
exec_com ()
# DESCRIPTION: Apply flags to modify script behavior, determine which
#   command the user has invoked, and perform some parsing and
#   validating of input until it's time to hand off to a more specific 
#   function
# INPUT: All positional parameters sent to qq2clone
# OUTPUT: Error messages/exit values as needed
# PARAMETERS: Pass "$@" directly here from the global scope
#=========================================================================#
{
parse_flags "$@"
local offset
offset="$(read_pipe)"
shift "$offset"
local com
com="$1"
shift

local verbose_coms
verbose_coms="config|check|list|list-templates|exec|edit|modify-template"
if (( OPT[QUIET] == 2)) &&
  [[ ! "$com" =~ ^($verbose_coms)$ 
]]; 
then
  exec &>/dev/null
fi

virsh uri |& grep -qi ^QEMU ||
  { echo "Current libvirt URI is not QEMU:///" >&2; exit "$E_libvirt"; }

[[ -n "$com" ]] || { usage >&2; exit "$E_args"; }

# Commands which don't want check_template run (in advance of calling them
# anyway)
if [[ "$com" == "check" ]]; then
  exec_com_check "$@"
  exit 0
elif [[ "$com" == "config" ]]; then
  exec_com_config "$@"
  exit 0
elif [[ "$com" == "copy-template" ]]; then
  exec_com_copy_template "$@"
  exit 0
elif [[ "$com" == "delete-template" ]]; then
  exec_com_delete_template "$@"
  exit 0
elif  [[ "$com" == "import-template" ]]; then
  exec_com_import_template "$@"
  exit 0
elif [[ "$com" == "list-templates" ]]; then
  exec_com_list_templates "$@"
  exit 0
elif [[ "$com" == "modify-template" ]]; then
  exec_com_modify_template "$@"
  exit 0
elif [[ "$com" == "edit" ]]; then
  exec_com_edit "$@"
  exit 0
elif [[ "$com" == "list" ]]; then
  exec_com_list "$@"
  exit 0
fi

# Clone and the set commands below get check_template run
if [[ "$com" == "clone" ]]; then
  check_template; template_error "$?"
  load_template
  exec_com_clone "$@"
  exit 0
fi

# All remaining commands require similiar logic to invoke, and act on sets 
# of machines. set_coms[$com] provides a list of arguments to exec_com_set
declare -A set_coms
set_coms["connect"]="connect Connected"
set_coms["destroy"]="destroy_domain Destroyed"
set_coms["exec"]="This one is a special case, this text isn't used"
set_coms["restore"]="start_domain Restored"
set_coms["resume"]="start_domain Resumed"
set_coms["rm"]="delete_machine Deleted 0"
set_coms["rm-wipe"]="delete_machine Deleted_and_wiped 1"
set_coms["rm-shred"]="delete_machine Deleted_and_shredded 2"
set_coms["save"]="save_domain Saved"
set_coms["save-rm"]="discard_save Discarded_saved_state 0"
set_coms["start"]="start_domain Started"
set_coms["suspend"]="suspend_domain Suspended"

local match=0 elem
for elem in "${!set_coms[@]}"; do
  [[ "$elem" == "$com" ]] && { match=1; break; }
done
((match)) || { echo "Unknown command $com" >&2; exit "$E_args"; }
(($#)) || arg_error 0 "$com"

load_template

local seq
seq="$(convert_to_seq "$1")" || set_error
shift

local set
set="$(seq_intersection "$seq" "$(get_target_set "$com")")"
[[ -n "$set" ]] || target_error "$com"

declare -a command_array
read -ra command_array <<<"${set_coms["$com"]}"
if [[ "$com" == exec ]]; then
 exec_com_exec "$set" "$@"
 exit 0
else
  (($#)) && arg_error 1 "$com"
fi

exec_com_set "$set" "${command_array[@]}"
exit 0
}
#=========================================================================#
exec_com_check ()
# DESCRIPTION: Attempt to find and solve problems regarding 
#   inconsistency between the database and UUIDs present on the libvirt
#   connection, files in qq2clone's pool that aren't associated with a
#   machine on the connection, or invalid template XML
# INPUT: Specify a template name, or nothing to act on all templates
# OUTPUT: Prompts and status updates
# PARAMETERS: $1: (optional) template name
#=========================================================================#
{
(($# > 1)) && arg_error 1 check
local t

declare -a templates
if (($#)); then
  check_template_exists "$1" || template_error 1
  templates[0]="$1"
else
  while read -r t; do
    templates=( "${templates[@]}" "$t" )
  done < <(get_template_list)
fi

for t in "${templates[@]}"; do
  echo "BEGIN CHECK TEMPLATE: $t"
  echo
  OPT[TEMPLATE]="$t"
  load_template
  if check_template; then
    echo "XML: Valid"
  else
    echo "XML: Invalid or missing"
    echo
    echo "Fix manually by repairing or replacing XML file at:"
    echo
    echo "  ${OPT[TEMPLATE_DIR]}/${t}.xml"
    echo
    echo "qq2clone cannot repair bad XML. Fix this problem manually, or"
    echo "allow qq2clone to delete the template and all of its clones."
    echo
    echo "Delete $t and all of its clones?"
    echo "(Backing template disk files will not be touched)"
    echo
    if prompt_yes_no; then
      delete_template_and_clones
      echo 
      hr
      continue
    fi
  fi
  echo
  
  local n sum
  
  sum="$(( ${#BAD_CL[@]} + ${#CL_MAP[@]} ))"
  echo "TOTAL CLONES: $sum"
  if (( ${#BAD_CL[@]} )); then
    echo
    echo "Of these clones, there are some that have either been deleted"
    echo "or undefined by a tool other than qq2clone, or exist on"
    echo "another libvirt URI and cannot presently be seen."
    echo
    echo "TOTAL MISSING CLONES: ${#BAD_CL[@]}"
    prompt_delete_bad_clones
  fi
  echo
  echo "END CHECK TEMPLATE: $t"
  echo
  hr
  echo
done

echo "Do a complete check for potentially orphaned images files now?"
prompt_yes_no && { echo; prompt_delete_orphans; }

exit 0
}
#=========================================================================#
exec_com_clone ()
# DESCRIPTION: Create clones of OPT[TEMPLATE]
# INPUT: A positive number, or nothing to create 1 clone
# OUTPUT: Outputs a total at the end, error messages/exit codes as needed
# PARAMETERS: $1: (Optional) a number
#=========================================================================#
{
(( $# < 2 )) || arg_error 1 "clone"
if (($#)); then
  [[ "$1" =~ ^[0-9]+$ ]] || arg_error 2 "clone" "$1"
fi

check_template_disks

(( $# == 0 )) && { clone; exit 0; }

local i
for ((i=0;i<$1;i++)); do
  clone
done

exit 0
}
#=========================================================================#
exec_com_config ()
# DESCRIPTION: View or change configuration options
# INPUT: subcommand and further arguments
# OUTPUT: Varies
# PARAMETERS: $1: Subcommand list, info, or edit, $2: option name (for 
#   info and edit), $3: new option value (for edit)
#=========================================================================#
{

if ((OPT[QUIET] == 2)); then
  [[ "$1" =~ ^(list|info)$  ]] || exec &>/dev/null
fi

(( $# )) || arg_error 0 config
              
if [[ "$1" == "list" ]]; then
  [[ -n "$2" ]] && arg_error 1 "config list"
  disp_conf_names
  exit 0
fi

local option
read -r option < <(echo "$2" | tr "[:lower:]" "[:upper:]")

if [[ "$1" == "info" ]]; then
  [[ -n "$2" ]] || arg_error 0 "config info"
  [[ -n "$3" ]] && arg_error 1 "config info"
  disp_conf_desc "$option" || exit "$E_args"
  exit 0
fi

if [[ "$1" == "edit" ]]; then
  [[ -n "$2" ]] || arg_error 0 "config edit"
  [[ -n "$4" ]] && arg_error 1 "config edit"
  check_config "$option" || { echo "Unknown option: $option"; 
    exit "$E_args"; }    
  local line
  if (($#==3));then
    line="$3"
  else
    ((OPT[QUIET]==2)) && exit "$E_args"
    echo "Enter new value for $2 without quotes:"
    read -r line
    line="$(strip_ws "$line")"
  fi
  local retval
  write_config "$option" "$line" || retval="$?"
  (( retval == 1 )) && arg_error 2 "config edit" "$2"
  (( retval == 2 )) &&
    { echo "Bad value for option $option: $line"; exit "$E_args"; }
  echo "Configuration value has been saved"
  exit 0
fi

arg_error 2 config "$1"
}
#=========================================================================#
exec_com_copy_template ()
# DESCRIPTION: Copy an existing template with a new name
# INPUT: The old and new template name
# OUTPUT: Status update/error messages
# PARAMETERS: $1: Existing template, $2: Copy's name
#=========================================================================#
{
(($# < 2)) && arg_error 0 copy-template
(($# > 2)) && arg_error 1 copy-template
local old new
old="${OPT[TEMPLATE_DIR]}/$1.xml" 
new="${OPT[TEMPLATE_DIR]}/$2.xml"

OPT[TEMPLATE]="$1"
check_template || template_error "$?"

template_name_available "$2"

write_pipe 1 <"${old}"
valid_xml_name_check "$2"
do_virt_xml --edit --metadata name="$2"

write_file "$new"

local md5
md5="$(get_md5 "$new")"

local disks
get_disk_devices <"$new"
disks="$(read_pipe)"

sqlite3 "insert into TEMPLATES values ('$2','$md5','$disks','1');"

(( OPT[QUIET] )) ||
  echo "Copy \"$2\" of template \"$1\" made successfully"
exit 0
}
#=========================================================================#
exec_com_delete_template ()
# DESCRIPTION: Delete an existing template
# INPUT: A template name
# OUTPUT: Status updates/error messages
# PARAMETERS: $1: Template name
#=========================================================================#
{
(( $# )) || arg_error 0 "delete-template"
(( $# > 1 )) && arg_error 1 "delete-template"
local txml="${OPT[TEMPLATE_DIR]}/${1}.xml"
OPT[TEMPLATE]="$1"
load_template
check_template; template_error "$?"

if [[ ! -e "$txml" ]]; then
  echo "No template named $1 exists" >&2
  exit "$E_template"
fi

local char
if ! ((OPT[QUIET])); then 
  echo "Are you sure you want to delete template $1? Storage volumes"
  echo "will not be touched."
  prompt_yes_abort || exit 0
fi

local check
check="$(sqlite3 "select exists \
  (select * from CLONES where template='$1');")"
if ((check));then
  echo "Clones must be deleted before their parent template" 
  echo "This can be done with:"
  echo
  echo "  qq2clone -t ${OPT[TEMPLATE]} rm all"
  echo "  qq2clone modify-template ${OPT[TEMPLATE]} discard-image"
  exit "$E_args"
fi >&2;

check_rw "$txml"
rm -f "$txml" &>/dev/null || unexpected_error exec_com_delete_template
sqlite3 "delete from TEMPLATES where name='$1';"

((OPT[QUIET])) || echo "Template $1 deleted"
exit
}
#=========================================================================#
exec_com_edit ()
# DESCRIPTION: Edit the XML of a clone
# INPUT: A machine number
# OUTPUT: Status messages/errors
# PARAMETERS: $1: A machine number
#=========================================================================#
{
  virsh edit "${CL_MAP["$1"]}"
  exit 0
}
#=========================================================================#
exec_com_exec ()
# DESCRIPTION: Execute arbitrary commands in a context where $uuid, $name,
#   and $disks are defined
# INPUT: A set of machines and a command string
# OUTPUT: Dependent on input
# PARAMETERS: $1: A set of machine numbers, $2 and on: arbitrary
#=========================================================================#
{
declare -a machines
read -ra machines <<<"$1"
shift
local elem uuid disks
for elem in "${machines[@]}"; do
  uuid="${CL_MAP["$elem"]}"
  name="${NAME_MAP["$elem"]}"
  disks="$(sqlite3 "select disks from CLONES where id='$elem' and \
    template='${OPT[TEMPLATE]}';")"
  export uuid name disks
  bash -ic "eval '$*'" ||
    { ((OPT[QUIET]==2)) || echo "Iteration of exec failed, abort" >&2;
      exit "$E_args"; }
done
exit 0
}
#=========================================================================#
exec_com_import_template ()
# DESCRIPTION: Import xml from a libvirt domain, or from a file
# INPUT: A filepath, or a libvirt domain name/uuid
# OUTPUT: Status updates if not OPT["QUIET"], error messages if named
#   domain/xml does not exist
# PARAMETERS:
#   $1: Absolute filepath to a libvirt domain XML file, or the name/uuid of
#     a domain defined on the current libvirt connection
#   $2: Optional. If set, use this value for template name rather than
#     the one in domain XML
#=========================================================================#
{
(( $# < 1 )) && arg_error 0 import-template
(( $# > 2 )) && arg_error 1 import-template
local xml
import_get_xml "$1"
xml="$(read_pipe)"

find_tag '//domain[@type="kvm"]/@type'<<<"$xml"
local match
match="$(read_pipe)"
if [[ -z "$match" ]]; then
  find_tag '//domain[@type="qemu"]/@type'<<<"$xml"
  match="$(read_pipe)"
  if [[ -z  "$match" ]]; then
    echo "Domain must be of type QEMU or KVM" >&2
    exit "$E_template"
  fi
fi

write_pipe 1 <<<"$xml"
get_template_name "$2" 
local xmlname name
{
read -r xmlname
read -r name
} < <(read_pipe)

write_pipe 1 <<<"$xml"
do_virt_xml --edit --metadata name="$name"
write_file "${OPT[TEMPLATE_DIR]}/${name}.xml"

get_disk_devices <"${OPT[TEMPLATE_DIR]}/${name}.xml"
local disks
disks="$(read_pipe)"

local md5
md5="$(get_md5 "${OPT[TEMPLATE_DIR]}/${name}.xml")"

sqlite3 "insert into TEMPLATES values ('$name','$md5','$disks','1');"

((OPT[QUIET])) || echo "Machine imported as: \"$name\""

if [[ "$1" =~ ^[^/] ]] && ! (( OPT[QUIET] )) ; then
  user_undefine_domain "$xmlname"
fi

exit 0
}
#=========================================================================#
exec_com_list ()
# DESCRIPTION: List clones
# INPUT: Nothing, "all", or "xml"
# OUTPUT: A list of clones and their state
# PARAMETERS: $1: (optional) "all" to run this command for all templates,
#   "xml" to produce an xml document with detailed information about
#   qq2clone's overall state
#=========================================================================#
{
(( $# > 1)) && arg_error 1 "list"  
if (($#)); then
  local line
  if [[ "$1" == "all" ]]; then
    local before=0
    while read -r line; do
      ((before)) && echo; before=1
      OPT[TEMPLATE]="$line"
      load_template
      list_display 0
    done < <(get_template_list)
  elif [[ "$1" == "xml" ]]; then
    echo "<qq2clone directory=\"${QQ2_DIR}\">" 
    local name value 
    while read -r name; do
      read -r value
      echo "  <config name=\"$name\" value=\"$value\" />"
    done < <(sqlite3 "select name,value from CONFIG;")
    echo "  <URI>${LIBVIRT_DEFAULT_URI:-missing}</URI>"
    while read -r line; do
      OPT[TEMPLATE]="$line"
      load_template
      list_display 1 
    done < <(get_template_list)
    echo "</qq2clone>"
  else
    arg_error 2 "list" "$1"
  fi
else
  [[ -z "${OPT[TEMPLATE]}" ]] &&
    { ((OPT[QUIET])) || echo "Specify the template to list" >&2
      exit "$E_template"; }
  check_template_exists || template_error 1
  load_template
  list_display
fi
exit 0
}
#=========================================================================#
exec_com_list_templates ()
# DESCRIPTION: List all template names
# INPUT: None
# OUTPUT: A list of template names
# PARAMETERS: None
#=========================================================================#
{
(($#)) && arg_error 1 list-templates
get_template_list
exit 0
}
#=========================================================================#
exec_com_modify_template ()
# DESCRIPTION: Modify image(s) of an existing template
# INPUT: Template name, subcommand, further arguments
# OUTPUT: Status updates/error messages
# PARAMETERS: $1: Template name, $2 and on: subcommand and further 
#   arguments, see man page or read the if/elifs below
#=========================================================================#
{
if ((OPT[QUIET] == 2)); then
  [[ "$2" == "edit" ]] || exec &>/dev/null
fi

(($#<2)) && arg_error 0 modify-template
(($#>3)) && arg_error 1 modify-template
if (($#==3)); then
  { [[ "$2" == "commit-image" ]] || [[ "$2" == "rename" ]] ; } ||
    arg_error 2 modify-template "$1" "$2" "$3" 
fi
OPT[TEMPLATE]="$1"

if [[ "$2" == "edit" ]]; then
  edit_xml
  exit 0
fi
check_template; template_error "$?"
load_template

local is_staging=0
[[ -n "${CL_STATE[0]}" ]] && is_staging=1
[[ -n "${BAD_CL[0]}" ]] && is_staging=2

if [[ "$2" == "prepare-image" ]]; then
  OPT[NORUN]=1
  ((is_staging == 2)) && stage_error
  ((is_staging)) || { clone 0; load_template; }
  connect 0
  
elif [[ "$2" == "commit-image" ]]; then
  ((is_staging == 2)) && stage_error
  if (($#==3)); then
    [[ "$3" == "force" ]] || arg_error 2 modify-template "$1" "$2" "$3"
  fi
  ((is_staging)) ||
    { echo "No changes are staged" >&2; exit "$E_args"; }
  commit_image "$@"
  
elif [[ "$2" == "destroy-image" ]]; then
  ((is_staging == 2)) && stage_error
  local state uuid
  state="$(get_state 0)"
  [[ "$state" == "running" ]] ||
    { echo "Domain is not running" >&2; exit "$E_args"; }
  uuid="${CL_MAP[0]}"
  virsh destroy "$uuid" &>/dev/null
  
elif [[ "$2" == "discard-image" ]]; then
  ((is_staging == 2)) && stage_error
  ((is_staging)) ||
    { echo "No image to discard" >&2; exit "$E_args"; }
  delete_machine 0 0
  ((OPT[QUIET])) || echo "Image discarded"
  
elif [[ "$2" == rename ]]; then
  (( $#==3)) || arg_error 0 "modify-template $1 $2"
  rename_template "$@"
else
  arg_error 2 "modify-template" "$2"
fi
exit 0
}
#=========================================================================#
exec_com_set ()
# DESCRIPTION: Any qq2clone command that acts on a set of machines, with
#   the exception of exec, uses this function to iterate over all machines 
#   in the set
# INPUT: Set of machines to act on, command to invoke, text to display to
#   user, and any additional parameters to pass on
# OUTPUT: Status updates after each iteration
# PARAMETERS: $1: the set to act on, $2: Function name, $3: Text to add 
#   onto status update at end of function, with _ replaced by space, $4 
#   and on: passed on to function called
#=========================================================================#
{
local set com text
set="$1"; shift
com="$1"; shift
text="$1"; shift

declare -a machines
read -ra machines <<<"$set"

while [[ "$text" =~ (.+)_+(.+) ]]; do
  text="${BASH_REMATCH[1]} ${BASH_REMATCH[2]}"
done

local elem
for elem in "${machines[@]}"; do
  "$com" "$elem" "$@"
  ((OPT[QUIET])) ||
    echo "${text}: ${OPT[TEMPLATE]}#${elem} ${CL_MAP["$elem"]}"
done

exit 0
}
#=========================================================================#
hr ()
# DESCRIPTION: Horizontal rule, constructed with -
# INPUT: None
# OUTPUT: Lots of -
# PARAMETERS: None
#=========================================================================#
{
echo ----------------------------------------------------------------------
}
#=========================================================================#
parse_flags ()
# DESCRIPTION: Check all flags and change global variables accordingly
# INPUT: exec_com passes $@ here, containing all cmd line parameters
# OUTPUT: write_pipe the number by which exec_com should shift,
#   or if unknown option is encountered exit with error message/code
# PARAMETERS: $@: Parameters to exec_com, originally from command line
#=========================================================================#
{
# Check for --quiter/-Q first
declare -a args
local d=0
args=( "$@" )
exec 8>&1
exec 9>&2

[[ "${args[0]}" == "--quieter" ]] && args[0]="-Q"
if [[ "${args[0]}" =~ ^\-Q ]]; then
  OPT[QUIET]=2
  exec &>/dev/null
fi

local short=":c:fghnqrs:St:vV"
local long="connection=c,no-spice=f,use-spice=g,help=h,"
long="${long}no-run=n,quiet=q,run=r,storage=s,spicy=S," 
long="${long}template=t,verbose=v,virt-viewer=V"

short_flags "$short" "$long" "${args[@]}"
read -ra args < <(read_pipe)
set -- "${args[@]}"

local opt optstring
while getopts "${short}Q" opt; do
  case "$opt" in
    c)  LIBVIRT_DEFAULT_URI="$OPTARG"
        export LIBVIRT_DEFAULT_URI
        virsh list &>/dev/null ||
        { echo "Virsh cannot connect to URI \"$OPTARG\", exiting" >&2;
          exit "$E_args"; }
    ;;
    f)  OPT[USE_SPICE]=0 
    ;;
    g)  OPT[USE_SPICE]=1
    ;;
    h)  ((OPT[QUIET]==2)) && exit "$E_args"
        ((OPT[QUIET]=0)); usage; exit 0
    ;;
    n)  OPT[NORUN]=1
    ;;
    q)  (( OPT[QUIET] )) || OPT[QUIET]=1
    ;;
    Q)  : # Handled above
    ;;
    r)  OPT[NORUN]=0
    ;;
    s)  storage_opt "$OPTARG"
    ;;
    S)  OPT[USE_SPICE]=1; OPT[SPICY]=1
    ;;
    t)  OPT[TEMPLATE]="$OPTARG"
        check_template_exists; template_error $?
    ;;
    v)  OPT[QUIET]=0
    ;;
    V)  OPT[USE_SPICE]=1; OPT[SPICY]=0
    ;;
    :)  [[ "$long" =~ (,|^)([^,]+)=$OPTARG  ]]
        optstring="--${BASH_REMATCH[2]}/-${OPTARG}"
        echo "Required argument to $optstring not found" >&2
        exit "$E_args"
    ;;
    *)  echo "Option \"$OPTARG\" is not recognized" >&2
        exit "$E_args"
  esac
done

((OPTIND+=d))
{ [[ -z "$OPTIND" ]] || (( OPTIND < 1 )) ; } && OPTIND=1

if [[ "${OPT[STORAGE]}/" =~ ^("${OPT[TEMPLATE_DIR]}/") ]]; then
  echo "Invalid storage location ${OPT[STORAGE]}"
  exit "$E_args"
fi

write_pipe 0 $(( OPTIND-1 ))
exec 1>&8 8>&- 
exec 2>&9 9>&-

return 0
}
#=========================================================================#
seq_intersection ()
# DESCRIPTION: Echo the intersection of two integer sets
# INPUT: Two space delimited integer sets
# OUTPUT: The intersection of the two sets, space delimited, ordered 
#   ascending
# PARAMETERS: $1, $2: Integer sets
#=========================================================================#
{
local n before=0
while read -r n; do
  [[ -z "$n" ]] && continue
  [[ ! " $2 " =~ [[:space:]]${n}[[:space:]] ]] && continue
  ((before)) && echo -n " "; before=1
  echo -n "$n"
done < <(tr " " "\n" <<<"$1" | sort -n | uniq)
echo

return 0
}
#=========================================================================#
short_flags ()
# DESCRIPTION: translate long option names into short ones
# INPUT: A string describing all short options, another mapping long
#   names to their short equivalents, and the arguments to check
# OUTPUT: write_pipe the parameters $3 and on passed to this function,
#   but with long names translated to short ones
# PARAMETERS: $1: a string of the type used by builtin getopts. Must
#   include ALL options, even those without a long name counterpart
#   $2: a string of the form a-long=a,b-long=b
#   $3 and on: all arguments to be checked
#=========================================================================#
{
local s_string="$1" l_string="$2"
shift 2
declare -a short_args=( "$@" )
local elem i

for ((i=0;i<${#short_args[@]};i++)); do
  elem="${short_args["$i"]}"
  if [[ "$elem" == "--" ]]; then
    break
  elif [[ "$elem" =~ ^-- ]]; then
    elem="${elem:2}"
    if [[ "$l_string" =~ (^|,)($elem)=(.) ]]; then
      elem="${BASH_REMATCH[3]}"
      short_args["$i"]="-$elem"
      ((i--))
    else
      echo "Unknown option: $elem" >&2
      exit "$E_args"
    fi
  elif [[ "$elem" =~ ^- ]]; then
    local len=$(( ${#elem} - 1 ))
    elem="${elem:${len}}"
    if [[ "$s_string" =~ $elem: ]]; then
      ((i++))
    fi
  else
    break
  fi
done

write_pipe 0 "${short_args[*]}"
return 0
}
#=========================================================================#
storage_opt ()
# DESCRIPTION: Helper for parse_flags. Handles checking and setting user
#   option defining OPT[STORAGE]
# INPUT: $OPTARG to -s option
# OUTPUT: None, except on error
# PARAMETERS: $1: argument to --storage/-s
#=========================================================================#
{
if [[ "$1" =~ ^/ ]]; then
  OPT["STORAGE"]="$1"
  check_dir "$1"
else
  virsh pool-info "$1" &>/dev/null ||
    { echo "No such pool \"$1\" exists on current libvirt connection" >&2;
      exit "$E_args"; }
  local line match=0
  virsh pool-dumpxml "$1" 2>/dev/null |
    find_tag "//pool[@type='dir']/target/path"
  while read -r line; do
    match=1
    [[ "$line" =~ ^[\<\>] ]] || OPT[STORAGE]="$line"
  done < <(read_pipe)
  ((match)) ||
    { echo "Specified pool is not of type dir, so it is not supported by"
      echo "qq2clone at this time"
      exit "$E_args"; } >&2
fi
return 0
}
#=========================================================================#
strip_ws ()
# DESCRIPTION: Strip any leading and trailing whitespace
# INPUT: A string
# OUTPUT: Echo the result
# PARAMETERS: $1: String to strip
#=========================================================================#
{
local str="$1"
if [[ "$str" =~ ^[[:space:]]+([^[:space:]].*)$ ]]; then
  str="${BASH_REMATCH[1]}"
fi
if [[ "$str" =~ ^(.*[^[:space:]])[[:space:]]+$ ]]; then
  str="${BASH_REMATCH[1]}"
fi
echo "$str"
return 0
}

                            #-----------------#
                            #@@@@@@@@@@@@@@@@@#
                            #---ENTRY POINT---#
                            #@@@@@@@@@@@@@@@@@#
                            #-----------------#

if ! ((QQ2_NOEXECUTE)); then
  open_pipe
  [[ -e "${HOME:?}/.config/qq2clone" ]] || first_run_setup
  get_config
  exec_com "$@"
  exit 0
fi