test/test-common

#
# test-common
#
# Common set of definitions and functions to help with driving VLANd
# in testing
#
# This specifically depends on *gawk* for the 2d arrays used in
# check_test_step() at the bottom

TOPDIR=$(dirname $0)/..

# Default settings
if [ "$VERBOSE"x = ""x ] ; then
    VERBOSE=0
fi
if [ "$HOSTS"x = ""x ] ; then
   HOSTS="panda01 panda02 panda03 arndale01 arndale02 arndale03 arndale04 imx5301 imx5302 imx5303"
fi
if [ "$SWITCHES"x = ""x ] ; then
    SWITCHES="vlandswitch01 vlandswitch02 vlandswitch03 vlandswitch04 vlandswitch05"
fi

LAST_COMMAND=""

# Topology definitions - how are the test machines connected?
panda01_SWITCH_PORT="vlandswitch01:Gi1/0/2"
panda02_SWITCH_PORT="vlandswitch02:fa25"
panda03_SWITCH_PORT="vlandswitch03:gi25"
arndale01_SWITCH_PORT="vlandswitch01:Gi1/0/3"
arndale02_SWITCH_PORT="vlandswitch02:fa2"
arndale03_SWITCH_PORT="vlandswitch03:gi2"
arndale04_SWITCH_PORT="vlandswitch04:Gi1/0/3"
imx5301_SWITCH_PORT="vlandswitch05:1/0/21"
imx5302_SWITCH_PORT="vlandswitch05:1/0/22"
imx5303_SWITCH_PORT="vlandswitch04:Gi1/0/2"

# Function for output; write text to terminal and to our logfile, with
# timestamp for sorting.
log () {
    DATE=$(date -u +%F/%H:%M:%S.%N)
    if [ "${LOGFILE}"x = ""x ] ; then
	LOGFILE=$0.log
    fi
    echo "${DATE}: $@" >&2 # Use stderr so we don't confuse anybody
			   # reading our output
    echo "   ${DATE}: $@" >> ${LOGFILE}
}

vecho () {
    if [ $VERBOSE -gt 0 ] ; then
	log "$@"
    fi
}

vvecho () {
    if [ $VERBOSE -gt 1 ] ; then
	log "$@"
    fi
}

# Run a vland admin command, and optionally log both the full text of
# the command and its output
run_admin_command () {
    ADMIN="python $TOPDIR/admin.py"
    vvecho "Running \"$ADMIN $@\""
    LAST_COMMAND="$@"
    RESULT=$($ADMIN $@)
    vvecho "  Result is \"$RESULT\""
    echo $RESULT
}

# Startup check
run_admin_command --status

# Preload some data - what are the switch IDs and port IDs of the
# various things in our test setup?
for SWITCH in $SWITCHES; do
    export ${SWITCH}_ID=$(run_admin_command --lookup_switch_by_name $SWITCH)
done

# Generate more detailed data for the hosts by asking VLANd what the
# IDs are for each port, etc.
for host in $HOSTS; do
    SWITCH_PORT_VAR=${host}_SWITCH_PORT
    SW=${!SWITCH_PORT_VAR%%:*}
    SW_VAR=${SW}_ID
    SW_ID=${!SW_VAR}
    PORT_NAME=${!SWITCH_PORT_VAR##*:}    
    PORT_ID=$(run_admin_command --lookup_port_by_switch_and_name $SW_ID $PORT_NAME)
    export ${host}_PORT_ID=${PORT_ID}    
    CURRENT_VLAN_ID=$(run_admin_command --get_port_current_vlan $PORT_ID)
    export ${host}_CURRENT_VLANID=$CURRENT_VLAN_ID    
    CURRENT_VLAN_TAG=$(run_admin_command --show_vlan_tag $CURRENT_VLAN_ID)
    export ${host}_CURRENT_VLAN_TAG=$CURRENT_VLAN_TAG
done

verify_host_is_base () {
    HOST=$1
    PORT_ID_VAR=${HOST}_PORT_ID
    PORT_ID=${!PORT_ID_VAR}
    CURRENT_VLAN_ID=$(run_admin_command --get_port_current_vlan $PORT_ID)
    CURRENT_VLAN_TAG=$(run_admin_command --show_vlan_tag $CURRENT_VLAN_ID)
    BASE_VLAN_ID=$(run_admin_command --get_port_base_vlan $PORT_ID)
    BASE_VLAN_TAG=$(run_admin_command --show_vlan_tag $BASE_VLAN_ID)
    vecho "$HOST"
    vecho "  is on port ID $PORT_ID"
    vecho "  which is on VLAN ID $CURRENT_VLAN_ID, tag $CURRENT_VLAN_TAG"
    vecho "  and should be on base VLAN ID $BASE_VLAN_ID, tag $BASE_VLAN_TAG"
    if [ $CURRENT_VLAN_ID == $BASE_VLAN_ID ] ; then
	return 0
    else
	return 1
    fi
}

verify_all_hosts_are_base () {
    # Check that all the machines are correctly on their base VLANs
    for host in $HOSTS; do
	verify_host_is_base $host
	if [ $? -ne 0 ] ; then
	    return 1
	fi
    done
}

all_hosts () {
    COMMAND="$@"
    for HOST in ${HOSTS}; do
    	vvecho "Running on ${HOST}:: ${COMMAND}"
        ssh linaro@${HOST} "${COMMAND}"
    done
}

start_logging () {
    vecho "Starting logging on hosts"
    all_hosts "echo HOSTS=\\\"$HOSTS\\\" > test-config"
}

stop_logging () {
    vecho "Stopping logging on hosts"
    all_hosts "rm -f test-config"
}

grab_logs () {
    vecho "Grabbing logs"
    all_hosts "cat /tmp/ping-log*"
}

clear_logs () {
    vecho "Clearing old logs on hosts"
    all_hosts "rm -f /tmp/ping-log*"
}

pause () {
    vecho "Pausing $1 seconds for systems to settle and/or log results"
    sleep $1
}

cleanup () {
    error=$?
    if [ $error -ne 0 ] ; then
	echo "Test script aborted with error $error - check logs for the failure"
	echo "  Last VLANd command appears to be \"$LAST_COMMAND\""
    fi
}

list_test_steps () {
    sort -u ${LOGFILE} | awk '
        /CHECK.*START/  {
            gsub("^.*CHECK ","")
            gsub(" START.*$","")
            start[$0]=1
        }
        /CHECK.*END/    {
            gsub("^.*CHECK ","")
            gsub(" END.*$","")
            if(start[$0] == 1) {
                print $0
                start[$0] = 0
            }
        }'
}

check_test_steps () {
    for STEP in $(list_test_steps); do
        echo "Checking connectivity results for ${STEP}: "
        check_test_step ${STEP}
    done
}

check_test_step () {
    STEP=$1
    sort -u ${LOGFILE} | awk -v STEP=$1 "
        /CHECK $STEP START/  { running=1 }
        /CHECK $STEP END/    { running=0 }
        /CHECK $STEP CHECK/  {
            for( i = 4; i <= NF; i++) {
                num_mach = split(\$i, mach_list, \":\")
                for (j = 2; j <= num_mach; j++) {
                    test[mach_list[1]][mach_list[j]] = 1
                }
            }
            if (0 == 1) {
                for (group in test) {
                    printf(\"  $STEP test group %s contains: \", group)
                    for (host in test[group]) {
                        printf(\"%s \", host)
                    }
                    printf(\"\n\")
                }
            }
        }
        /UP/                 {
            if(running) {
                OK=0
                for (group in test) {
                    if (test[group][\$2] && test[group][\$4]) {
                        #printf(\"GOOD UP: %s to %s (%s)\n\",\$2,\$4,group)
                        OK=1
                        success++
                    }
                }
                if (OK == 0) {
                    printf(\"    BAD UP: %s to %s\n\",\$2,\$4)
                    fail++
                }
            }
        }
        /DOWN/               {
            if(running) {
                OK=1
                for (group in test) {
                    if (test[group][\$2] && test[group][\$4]) {
                        printf(\"    BAD DOWN: %s to %s (%s)\n\",\$2,\$4,group)
                        OK=0
                        fail++
                    }
                }
                if (OK == 1) {
                    # printf(\"GOOD DOWN: %s to %s\n\",\$2,\$4)
                    success++
                }
            }
        }
        END { printf(\"  success: %d, fail: %d\n\", success, fail) }
"
}

trap cleanup 0