source: tags/confman-1.5.4.2/confman @ 145

#! /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$

. /usr/local/rescomp/lib/confmancommon.sh

# 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

# 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
                echo "BugId: " >> $msg
                ${EDITOR} $msg
                sudo -v
                update || conf_cleanexit

                echo "Commit operation started" >&2
        conf_commit "$LAYERS" $msg || return $?
                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
        conf_recordAction commit
        conf_markclean
                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
        else
                local msg=`mktemp -t confman`
                # Moved up per Ian's request.
                echo "Change this file to your log message." > $msg
                echo "BugId: " >> $msg
                ${EDITOR} $msg
                sudo -v
                update || conf_cleanexit

                echo "Installation operation started." >&2
        conf_commit "$LAYERS" $msg || return $?
                for layer in $LAYERS ; do
                        conf_install $layer "$@"
                done
                for file in $SINGULARITIES ; do
                        conf_assemble_sing $file || conf_cleanexit
                done
        conf_recordAction install
        if ! conf_isclean ; then
            echo "WARNING: Recent 'install' operations prevented a 'sync'" >&2
            echo "Running a 'commit' is highly recommended." >&2
        fi
                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." \
                        "Skipping." >&4
                import $module $*
                return
        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. Skipping." >&4
                                echo "Did you mean -f ?" >&4
                                import $module $*
                                return
                        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`
        elif sudo [ -d "$file" ] ; then
                import $module $* ${file}/*
                return
        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
        rm -f $usefile

        # 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
}

function lsattr {
    if [ -z "$1" ] ; then
        conf_lsattr *
    else
        conf_lsattr "$@"
    fi
}

function chattr {
    local attr="$1"
    shift
    local value="${1:-true}"
    shift
    if [ -z "$1" ] ; then print_usage 1 ; fi

    conf_chattr "$attr" "$value" "$@"
}

function rmattr {
    local attr="$1"
    shift
    if [ -z "$1" ] ; then print_usage 1 ; fi

    conf_rmattr "$attr" "$@"
}

function state {
    if conf_isclean ; then
        echo "This host is clean."
    else
        echo "This host may be dirty. Consider running a 'commit' operation"
    fi
}

# 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 )                        status "$@" ;;
    state )                         state ;;
    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 "$@" ;;
    lsattr )                        lsattr "$@" ;;
    chattr )                        chattr "$@" ;;
    rmattr )                        rmattr "$@" ;;
    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 

exit

# vim:ts=4