source: tags/confman-1.3.1/confman @ 111

#! /bin/bash
#
# confman provides a command-line interface to Rescomp's server configuration 
# management system.
#
# confman --help
#       Print help and usage information
#
# Author: Chris Cowart <ccowart@rescomp.berkeley.edu>
# Date: 30 March 2006
#
# $Id$



# Some global definitions. Defaults that can be overriden by options.
GCONF="/usr/local/rescomp/etc/confman.conf"
UCONF="${HOME}/.confmanrc"
MYNAME=`basename $0`

# First things first. Check to see if the logging fd is open. If it's not,
# we re-spawn confman inside a pipe.
if (true >&5) 2>/dev/null ; then
        exec 4>&2 2>&5 >&3-
else
        exec 3>&1
        exec $0 $* 5>&1 1>&3 | logger -t "$MYNAME ($USER)" -s
        exit ${PIPESTATUS[0]}
fi

# Get the global config
if [ -f $GCONF ] ; then 
        . $GCONF
else
        echo "Global config file couldn't be located" >&2
        exit 1
fi

# Get the user config
if [ -f $UCONF ] ; then
        . $UCONF
fi

# Set debugging:
if [ -z $DEBUG ] ; then
        DEBUG="false"
fi

# Now, we source the library
if [ -f $REPO_LIBRARY ] ; then
        . $REPO_LIBRARY
else
        echo "Couldn't source the confman shell library" >&2
        exit 1
fi

# And the documentation library
if [ -f $REPO_DOCS ] ; then
        . $REPO_DOCS
else
        echo "Couldn't source the confman shell library" >&2
        exit 1
fi

# And we read in the layers that make this host
if [ -f $RECIPE_PATH ] ; then
        LAYERS=`cat $RECIPE_PATH | grep "^[^#]"`
else
        echo "Couldn't read the host's recipe!" >&2
        exit 1
fi

# Set a default editor
if [ -z ${EDITOR} ] ; then
        if which vim >/dev/null 2>&1 ; then
                EDITOR="vim"
        else
                EDITOR="vi"
        fi
fi

# Let's make sure that only you can read your working copy
# Have to make this less restrictive due to NFS home dirs.
umask 022

# And we'll set a trap:
trap "conf_cleanexit" SIGINT SIGTERM


# This function implements the setup subcommand. It is intended to be called
# with no arguments, and will error if that's not the case.
function setup {
        local response
        $DEBUG && echo "Running setup" >&4
        if [ ! -z $* ] ; then
                print_usage 1
        elif [ -d ${WORK_PATH} ] ; then
                echo "Looks like ${WORK_PATH} already exists." 
                echo "Start over by removing it? (y/N)"
                read response
                if [[ $response =~ '^[yY](es|ES)?' ]] ; then
                        rm -rf ${WORK_PATH}
                        setup
                else
                        echo "Setup failed." >&4
                        exit 1
                fi
        else
                conf_checkout_tree
        fi
}

function create {
        local module=$1
        shift
        if [ -z $* ] ; then
                conf_create_module $module
        else
                print_usage 1
        fi
}

function update {
        if [ -z $* ] ; then
                conf_update_tree || conf_cleanexit
        else
                print_usage 1
        fi
}

function revert {
        if [ -z $* ] ; then
                print_usage 1
        else
                conf_revert $*
        fi
}

function commit {
        if [ -z $* ] ; then
                local msg=`mktemp -t confman`
                # Moved up per Ian's request.
                echo "Change this file to your log message." > $msg
                ${EDITOR} $msg
                sudo -v
                update || conf_cleanexit

                echo "Commit operation started" >&2
                for layer in $LAYERS ; do
                        conf_commit $layer $msg || return $?
                done
                for layer in $LAYERS ; do
                        echo "Rolling on $layer..."
                        conf_rollout $layer || return $?
                done
                for file in $SINGULARITIES ; do
                        conf_assemble_sing $file || return $?
                done
                echo "Commit operation finished successfully" >&2
                rm -f $msg

        else
                print_usage 1
        fi
}

# Short name intentional, don't want collision with real install.
function inst {
        local file livefile

        if [ -z "$*" ] ; then
                print_usage 1
# This check is handled in the library. Calling on a non-existant file isn't
# necessarily a syntax error.
#       elif [ ! -e $1 ] ; then
#               echo File $1 not found!
#               print_usage 1
        else
                local msg=`mktemp -t confman`
                # Moved up per Ian's request.
                echo "Change this file to your log message." > $msg
                ${EDITOR} $msg
                sudo -v
                update || conf_cleanexit

                echo "Installation operation started." >&2
                for layer in $LAYERS ; do
                        $DEBUG && echo "Layer: $layer" >&4
                        conf_commit $layer $msg || return $?
                        conf_install $layer $*
                done
                for file in $SINGULARITIES ; do
                        conf_assemble_sing $file || conf_cleanexit
                done
                echo "Installation operation succeeded." >&2
        fi
}
        

function import {
        
        # Check for a force
        local item OPTIND
        force=0
        while getopts "f" opt ; do
                case $opt in 
                        f)
                        force=1
                        shift
                        ;;
                        *)
                        print_help 1
                        ;;
                esac
        done

        local module=$1
        local response usefile suffix file layer
        local mode=$DEFAULT_MODE_FILE
        local owner=$DEFAULT_OWNER
        local group=$DEFAULT_GROUP
        local comment=$DEFAULT_COMMENT
        shift
        if [ -z $1 ] ; then
                print_usage 1
        fi

        sudo -v
        if [ -r $1 ] ; then
                file=`abspath $1`
        else
                # If we can't enter the parent directory, this will help us
                # get the info we need.
                file=`sudo abspath $1`
        fi
        shift


        # See if we're importing a singularity
        if [[ "$SINGULARITIES" =~ "$file" ]] ; then
                suffix="-$module"
        fi

        # Error out when trying to import a symbolic link.
        if sudo [ -L $file ] ; then
                echo "$file is a symbolic link!" >&4
                conf_cleanexit
        fi

        if [ -f ${WORK_PATH}/${module}${file}${suffix} ] ; then
                echo "$file already exists in your working copy of $module." >&4
                conf_cleanexit
        fi

        if [ $force = 0 ] ; then
                for layer in $LAYERS ; do
                        if [ -f ${WORK_PATH}/${layer}${file}${suffix} ] ; then
                                echo "$file already exists in the ${layer}" \
                                     "module." >&4
                                echo "Did you mean -f ?" >&4
                                conf_cleanexit
                        fi
                done
        fi

        if sudo [ -f $file ] ; then
                eval `sudo stat -f "mode=%Mp%Lp owner=%Su group=%Sg" $file`
                # Let's make our best guess on the comment character:
                local tmpfile=`mktemp -t confman`
                local biggestcount=0
                local count

                # Let's see if we can read the file as ourself:
                usefile=`mktemp -t confman`
                if [ ! -r $file ] ; then
                        sudo cat $file > $usefile
                else
                        cat $file > $usefile
                fi

                # Put all non-alphanumerics into a file
                awk '{print $1}' $usefile | egrep -o \
                        "^[^-_A-Za-z0-9]" > $tmpfile

                for char in `cat $tmpfile | sort | uniq` ; do
                        count=`egrep -o "\\$char" $tmpfile | wc -l`
                        if [ $count -gt $biggestcount ] ; then
                                biggestcount=$count
                                comment="$char"
                        fi
                done
                rm $tmpfile

                # Convert mode string to base 10:
                mode=`echo "obase=10;ibase=8;$mode" | bc`
                # And use a bitmask to subtract off all write-access
                # 3949d = 7555o
                mode=$(($mode & 3949))
                # And back to an octet:
                mode=`printf '%04o\n' $mode`
        else
                # Prompt for file owner
                echo "Who should be the file's owner? [ $owner ]"
                read response
                if [ ! -z $response ] ; then
                        owner=$response
                fi

                # And file's group
                echo "Who should be the file's group? [ $group ]"
                read response
                if [ ! -z $response ] ; then
                        group=$response
                fi

                # now, the permissions
                echo "What should the file's permissions be? [ $mode ]"
                read response
                if [ ! -z $response ] ; then
                        mode=$response
                fi

                # now, the comment character
                echo "What string starts comment lines? [ $comment ]"
                read response
                if [ ! -z $response ] ; then
                        comment=$response
                fi
        fi

        if [ ! -d "${WORK_PATH}/${module}`dirname $file`" ] ; then
                newdir "${WORK_PATH}/${module}`dirname $file`"
        fi

        # Time to generate the file
        conf_gen_file $module "${file}${suffix}" $owner $group \
                $mode "$comment" $usefile

        # Removing temporary files
        if [ -f $usefile ] ; then
                rm $usefile
        fi

        # Are there more files to import?
        if [ ! -z $1 ] ; then
                import $module $*
        fi

}

function remove {
        if [ -z $1 ] ; then print_usage 1 ; fi
        conf_rm_file $*
}

function newdir {
        local dir=$1
        local response module realpath
        local mode=$DEFAULT_MODE_DIRECTORY
        local owner=$DEFAULT_OWNER
        local group=$DEFAULT_GROUP
        local comment="dir"
        local workdir=`abspath .`
        if [ -z $1 ] ; then
                print_usage 1
        fi

        # Find the "real" directory's path
        if [[ ! $dir =~ "^\/" ]] ; then
                dir="${workdir}/${dir}"
        fi
        module=`echo ${dir#$WORK_PATH} | sed -E 's:/([^/]+)/.*:\1:'`
        realpath=${dir#${WORK_PATH}/${module}}

        if [ -d $realpath ] ; then
                eval `sudo stat -f "mode=%Mp%Lp owner=%Su group=%Sg" $realpath`

                # Convert mode string to base 10:
                mode=`echo "obase=10;ibase=8;$mode" | bc`
                # And use a bitmask to subtract off all write-access
                # 3949d = 7555o
                mode=$(($mode & 3949))
                # And back to an octet:
                mode=`printf '%04o\n' $mode`
        else
                # Prompt for file owner
                echo "Who should be the directory's owner? [ $owner ]"
                read response
                if [ ! -z $response ] ; then
                        owner=$response
                fi

                # And file's group
                echo "Who should be the directory's group? [ $group ]"
                read response
                if [ ! -z $response ] ; then
                        group=$response
                fi

                # now, the permissions
                echo "What should the directory's permissions be? [ $mode ]"
                read response
                if [ ! -z $response ] ; then
                        mode=$response
                fi
        fi

        # Time to create the directory.
        echo "Making directory $dir with ${owner}:${group}, $mode"
        conf_mkdir $dir $owner $group $mode 
}

function list {
        local file item
        if [ -z $1 ] ; then 
                file=`abspath .`
        else
                file=`abspath $1`
        fi
        echo -e "--------------------------------------------------------"
        echo -e "Mode\tOwner\tGroup\tComment\t\tFilename"
        echo -e "--------------------------------------------------------"
        if [ -f "$file" ] ; then
                conf_list $file
        elif [ -d "$file" ] ; then
                for item in `ls $file` ; do
                        conf_list "$file/$item"
                done
        fi
}

function status {
        conf_status $*
}

function chowner {
        local recursive item OPTIND
        while getopts "R" opt ; do
                case $opt in
                        R)
                        recursive=1
                        shift
                        ;;
                        *)
                        print_help 1
                        ;;
                esac
        done
        local owner=$1
        local file=$2
        conf_set_prop $file owner $owner
        if [ ! -z $recursive ] && [ -d $file ] ; then
                for item in $file/* ; do
                        chowner -R $owner $item
                done
        fi
}

function chgroup {
        local recursive item OPTIND
        while getopts "R" opt ; do
                case $opt in
                        R)
                        recursive=1
                        shift
                        ;;
                        *)
                        print_help 1
                        ;;
                esac
        done
        local group=$1
        local file=$2
        conf_set_prop $file group $group
        if [ ! -z $recursive ] && [ -d $file ] ; then
                for item in $file/* ; do
                        chgroup -R $group $item
                done
        fi
}

function chmode {
        local recursive item OPTIND
        while getopts "R" opt ; do
                case $opt in
                        R)
                        recursive=1
                        shift
                        ;;
                        *)
                        print_help 1
                        ;;
                esac
        done
        local mode=$1
        local file=$2
        conf_set_prop $file mode $mode
        if [ ! -z $recursive ] && [ -d $file ] ; then
                for item in $file/* ; do
                        chmode -R $mode $item
                done
        fi
}

function chcom {
        local comment="$1"
        local file=$2
        conf_set_prop $file comment "$comment"
}

function checklook {
        local module=$1
        local chkdir=${WORK_PATH}/${REPO_CHECKPTS}/${module}
        if [ -z $1 ] ; then
                print_usage 1
        elif [ -d $chkdir ] ; then
                ls $chkdir
        else
                echo "There are no checkpoints for ${module}."
        fi
}

function checknew {
        local module=$1
        local checkpoint=$2
        if [ -z $2 ] ; then
                print_usage 1
        else
                conf_new_checkpoint $module $checkpoint
        fi
}

function checkclear {
        local module=$1
        local checkpoint=$2
        if [ -z $2 ] ; then
                print_usage 1
        else
                conf_rm_checkpoint $module $checkpoint
        fi
}

function rollback {
        local module=$1
        local checkpoint=$2
        local clock=$3
        if [ -z $2 ] ; then
                print_usage 1
        else
                echo "Rolling $module back to $checkpoint $clock" >&2
                conf_rollback $module $checkpoint $clock || conf_cleanexit
                for layer in $LAYERS ; do
                        echo "Rolling on $layer..."
                        conf_rollout $layer || conf_cleanexit
                done

                for file in $SINGULARITIES ; do
                        conf_assemble_sing $file || conf_cleanexit
                done
                echo "Rollback succeeded." >&2
        fi
}

function rmmod {
        local module=$1
        if [ -z $module ] ; then
                print_usage 1
        fi
        conf_rmmod $module
}

function rename {
        local oldmod=$1
        local newmod=$2
        if [ -z $newmod ] ; then
                print_usage 1
        fi
        if [ ! -d "${WORK_PATH}/${oldmod}" ] ; then
                echo "${MYNAME}: Error: ${WORK_PATH}/${oldmod} doesn't exist" >&4
                conf_cleanexit
        fi
        if [ -e "${WORK_PATH}/${newmod}" ] ; then
                echo "${MYNAME}: Error: ${WORK_PATH}/${newmod}: file exists" >&4
                conf_cleanexit
        fi
        conf_rename $oldmod $newmod
}

function diff {
        conf_diff $*
}

function log {
        conf_log $*
}

function copy {
        local src=$1
        local dest=$2

        if [ -z $2 ] ; then print_usage 1 ; fi

        conf_cp $src $dest
}

function move {
        local src=$1
        local dest=$2

        if [ -z $2 ] ; then print_usage 1 ; fi

        conf_mv $src $dest
}

# Dubug mode?
while getopts "d" opt ; do
        case $opt in
                d)
                DEBUG="true"
                shift
                ;;
                *)
                print_help 1
                ;;
        esac
done


# Dispatch the subcommand. This must happen last and in the global context.
subcommand=$1
shift
case $subcommand in
        help )                                                  print_help $* ; exit 0 ;;
        setup|se* )                                             setup $* ;;
        status|st* )                                    status $* ;;
        create|cr* )                                    create $* ;;
        update|u* )                                             update $* ;;
        commit|com* )                                   commit $* ;;
        import|im* )                                    import $* ;;
        install|in* )                                   inst $* ;;
        remove|rem*|rm )                                remove $* ;;
        rev* )                                                  revert $* ;;
        ren* )                                                  rename $* ;;
        rmmod )                                                 rmmod $* ;;
        mkdir|mkd* )                                    newdir $* ;;
        list|ls )                                               list $* ;;
        move|mv )                                               move $* ;;
        copy|cp )                                               copy $* ;;
        diff )                                                  diff $* ;;
        log )                                                   log $* ;;
        chmod )                                                 chmode $* ;;
        chown )                                                 chowner $* ;;
        chcom )                                                 chcom $* ;;
        chgrp )                                                 chgroup $* ;;
        checklook|checklist|chls|chlk ) checklook $* ;;
        checknew|chnw )                                 checknew $* ;;
        checkclear|chcl|chrm )                  checkclear $* ;;
        rollback|ro* )                                  rollback $* ;;
        * )                                                             print_usage 1 ;;
esac 

# We shouldn't be here.
exit 1

# vim:ts=4