example/diameter/launcher/deployments/st-client/program.sh

   1 #!/bin/bash
   2
   3 #############
   4 # VARIABLES #
   5 #############
   6 ADML_INSTANCES=`cat .st_conf_adml_instances 2>/dev/null`
   7 RATE_PER_INSTANCE=`cat .st_conf_rate_per_instance 2>/dev/null`
   8 DESIRED_RATE=`cat .st_conf_desired_rate 2>/dev/null`
   9 REPEATS=`cat .st_conf_cycle_repeats 2>/dev/null`
  10 PROGRAM_LAYOUT_FILE=.st_conf_n_testcases_program_layout
  11 [ -z "$ADML_CONCURRENT_PROVISION_JOBS" ] && ADML_CONCURRENT_PROVISION_JOBS=20
  12
  13 #############
  14 # FUNCTIONS #
  15 #############
  16 _exit() {
  17   echo -e "\n$1\n"
  18   exit 1
  19 }
  20
  21 usage() {
  22   cat << EOF
  23 Usage: $0 <test stuff directory|dynamic> [-s]
  24
  25        Performs test case programming from scratch (current test cases will be dropped
  26         from ADML involved instances). There are two types of programming depending on
  27         the first argument provided:
  28
  29        test stuff directory:
  30
  31           The folder provided must contain msk files, specially a testcase file with
  32           xml files referenced inside. Those xml files (without the .msk extension)
  33           shall exists in the directory. For example:
  34
  35              $0 st_examples/DynamicQualification
  36
  37           Optionally, a file 'specific' could exists containing testcase-specific
  38           information, which normally will be used to specify database sentences.
  39           This file will be accumulated as a cloning seed over the file 'specific.all'
  40           created on test stuff directory.
  41
  42           Template type programming could be used for medium-duration testings, because
  43           the scripting used for programming, have lots of groups divisions which even
  44           background-executed are much more slower on programming than a c++ builtin
  45           procedure: dynamic type is the one for large sets of test cases:
  46
  47
  48        dynamic:
  49
  50           The current dynamic procedure selected by mean 'dynlibs/select.sh' script,
  51           will be programmed using its dirname resources: inside, you may found not
  52           only the .so library but the needed xml files for the implemented scenary
  53           and a file called 'dynamic.suffix' used to complete the dynamic operation
  54           in this way:
  55
  56              dynamic|<initial sequence>|<final sequence>|<dynamic.suffix content>
  57
  58           For example, you could have this content for 'dynamic.suffix':
  59
  60              0|7|CCR-I.xml|CCR-T.xml                    (0 for timeout means no timeout step)
  61
  62           in order to generate the operation:
  63
  64              dynamic|<initial sequence>|<final sequence>|0|7|CCR-I.xml|CCR-T.xml
  65
  66           which would be parsed for the specific ADML instance programmed:
  67
  68              dynamic|2000001|2001000|0|7|CCR-I.xml|CCR-T.xml
  69
  70           The file 'dynamic.suffix' could have several lines for several scenaries.
  71           In this case, this script will prompt for the desired one.
  72
  73           This script will build every operation for the configured ADML instances
  74           to complete all the sequence ranges along the whole test system.
  75
  76
  77
  78        -s: start testing just after programming, using desired rate: $DESIRED_RATE test cases per second.
  79 EOF
  80   [ $ADML_INSTANCES -gt 1 ] && echo "           In your case, with $ADML_INSTANCES, a rate of $RATE_PER_INSTANCE ttps will be send per instance."
  81   echo
  82   _exit
  83 }
  84
  85 advice_to_squeeze_idle_cpu () {
  86   local idle=$(top -b -d 0.1 -n 2 | grep 'Cpu(s):'| tail -1 | awk '{print $8}' | sed 's/,/./')
  87   sleep 10
  88   echo
  89   echo  "Idle cpu now: $idle. Check the system CPU with top. If is not overcommited, consider"
  90   echo " increase the environment variable 'ADML_CONCURRENT_PROVISION_JOBS' (now $ADML_CONCURRENT_PROVISION_JOBS)."
  91   echo
  92   echo "Press ENTER to continue ..."
  93   read dummy
  94 }
  95
  96 #############
  97 # EXECUTION #
  98 #############
  99 miss_conf=
 100 [ ! -f .st_conf_adml_instances ] && miss_conf=yes
 101 [ ! -f .st_conf_n_testcases_program_layout ] && miss_conf=yes
 102 [ ! -f .st_conf_cycle_repeats ] && miss_conf=yes
 103 [ ! -f .st_conf_rate_per_instance ] && miss_conf=yes
 104 [ ! -f .st_conf_desired_rate ] && miss_conf=yes
 105 [ -n "$miss_conf" ] && _exit "You must run './configure.sh' script firtly !!"
 106
 107 echo
 108 [ -z "$1" ] && usage
 109 echo "Testcases programming ..."
 110 echo
 111 cd `dirname $0`
 112 ./checkStatus.sh
 113 [ $? -eq 1 ] && _exit "Fix status (instances) to continue ..."
 114
 115 # We launch in background !
 116 #./operation.sh --ping >/dev/null
 117 #[ $? -ne 0 ] && _exit "Programming aborted (some ADML client process is not running) !"
 118
 119 # Arguments:
 120 PROG_TYPE=$1
 121 AUTOSTART=$2
 122
 123 # test case stuff programming #########################################################
 124 if [ "$PROG_TYPE" != "dynamic" ]
 125 then
 126   TESTCASE_DIR=$PROG_TYPE
 127
 128   [ ! -d $TESTCASE_DIR ] && _exit "Cannot found the test directory '$TESTCASE_DIR' !!"
 129   TESTCASE=( `ls $TESTCASE_DIR/testcase*msk 2>/dev/null` )
 130   TESTCASE_FILES=${#TESTCASE[@]}
 131   [ $TESTCASE_FILES -ne 1 ] && _exit "One and only one 'testcase*msk' file must be present !!"
 132
 133   MAX_NUMBER_GROUPS=$(grep ^MAX_NUMBER_GROUPS= clone.sh | cut -d= -f2)
 134   CLONE_GROUPS=$((MAX_NUMBER_GROUPS/ADML_INSTANCES))
 135   #CLONE_GROUPS=1
 136   specific=
 137   [ -f $TESTCASE_DIR/specific ] && specific=specific
 138
 139   count=0
 140   while read -r line
 141   do
 142     instance=$(echo $line | awk '{ print $1 }')
 143     ini_seq=$(echo $line | awk '{ print $2 }')
 144     fin_seq=$(echo $line | awk '{ print $3 }')
 145     ADML_DIR=`readlink -f ADMLS/ADML-$instance`
 146     echo -e "\rCloning interval [$ini_seq,$fin_seq] for $(basename $ADML_DIR) ..."
 147     ./clone.sh $ADML_DIR $TESTCASE $ini_seq $fin_seq $CLONE_GROUPS $specific &
 148     sleep 0.1
 149     count=$((count+1))
 150     if [ $count -eq $ADML_CONCURRENT_PROVISION_JOBS ]
 151     then
 152       wait $(jobs -p)
 153       count=0
 154     fi
 155
 156   done < $PROGRAM_LAYOUT_FILE
 157
 158   # Advice for idle cpu:
 159   advice_to_squeeze_idle_cpu
 160
 161   # Wait background jobs to finish:
 162   sleep 5
 163   echo "Waiting for clone completion ..."
 164   echo "(please be patient, this may take a while)"
 165   echo
 166   echo "Background Jobs: $(jobs -p | wc -l)"
 167   wait $(jobs -p)
 168
 169   echo
 170   echo "Programming has finished !"
 171   echo
 172
 173   if [ -n "$specific" ]
 174   then
 175     echo "A new file '$TESTCASE_DIR/specific.all' has been created."
 176     echo "Probably you need to apply it before starting traffic."
 177     echo
 178     echo "Press ENTER to continue, CTRL-C to abort ..."
 179     read dummy
 180   fi
 181
 182 # dynamic programming #################################################################
 183 else
 184   TESTCASE_DIR=$(readlink -f dynlibs/liblauncher_procedure_default_shared.so | xargs dirname)
 185   DYNAMIC_SUFFIX_FILE=$TESTCASE_DIR/dynamic.suffix
 186
 187   [ ! -f $DYNAMIC_SUFFIX_FILE ] && _exit "Missing '$DYNAMIC_SUFFIX_FILE' file.\nUse 'dynlibs/select.sh' to change the dynamic procedure and restart the ADML instances."
 188   dynamic_suffix=( $(grep -v ^# $DYNAMIC_SUFFIX_FILE) )
 189
 190   # Multiple scenarios:
 191   suffixes=${#dynamic_suffix[@]}
 192   if [ $suffixes -gt 1 ]
 193   then
 194     echo
 195     echo "----------------------------------------------------------------"
 196     cat $DYNAMIC_SUFFIX_FILE
 197     echo "----------------------------------------------------------------"
 198     echo
 199     echo "Detected $suffixes scenarios:"
 200     echo
 201     tmpfile=$(mktemp)
 202     opt=1
 203     for line in $(grep -v ^# $DYNAMIC_SUFFIX_FILE)
 204     do
 205       echo "${opt}) $line"
 206       opt=$((opt+1))
 207     done > $tmpfile
 208     cat $tmpfile
 209     echo
 210     echo "Select the desired option (0 to input a user defined one):"
 211     read option
 212     while [ -z "$option" ]; do read option ; done
 213     if [ "$option" != "0" ]
 214     then
 215       dynamic_suffix=$(grep "^${option}) " $tmpfile | cut -d" " -f2-)
 216       [ -z "$dynamic_suffix" ] && _exit "Invalid option !"
 217     else
 218       echo "Input specific program arguments:"
 219       echo " (be sure that are supported by the dynamic procedure)"
 220       echo
 221       read dynamic_suffix
 222       while [ -z "$dynamic_suffix" ]; do read dynamic_suffix ; done
 223     fi
 224   fi
 225
 226   # Modify xml files path:
 227   xmls=( $(echo $dynamic_suffix | sed 's/'\|'/ /g') )
 228   dynamic_suffix=$(for xml in ${xmls[@]}
 229   do
 230     echo $xml | grep -q "\.xml$"
 231     [ $? -eq 0 ] && echo -n "$TESTCASE_DIR/"
 232     echo -n "${xml}|"
 233   done | sed 's/'\|'$//')
 234
 235   # If still idle CPU, you could increase chunks number of background jobs
 236   echo "Dynamic programming ..."
 237   echo
 238   while read -r line
 239   do
 240     instance=$(echo $line | awk '{ print $1 }')
 241     ini_seq=$(echo $line | awk '{ print $2 }')
 242     fin_seq=$(echo $line | awk '{ print $3 }')
 243     ADML_DIR=`readlink -f ADMLS/ADML-$instance`
 244
 245     cd $ADML_DIR
 246     ./operation.sh -t 60 "dynamic|$ini_seq|$fin_seq|$dynamic_suffix" &
 247     sleep 0.1
 248     count=$((count+1))
 249     if [ $count -eq $ADML_CONCURRENT_PROVISION_JOBS ]
 250     then
 251       wait $(jobs -p)
 252       count=1
 253     fi
 254     cd - >/dev/null
 255
 256   done < $PROGRAM_LAYOUT_FILE
 257
 258   # Advice for idle cpu:
 259   advice_to_squeeze_idle_cpu
 260
 261 fi
 262
 263 echo
 264 echo
 265 echo "Configuring repeat cycles ..."
 266 ./operation.sh "test|repeats|$REPEATS" >/dev/null
 267 echo
 268 echo "Done !"
 269 echo
 270
 271 start_testing=
 272 if [ "$AUTOSTART" = "-s" ]
 273 then
 274   start_testing=yes
 275 else
 276   cat << EOF
 277
 278 To start testing, you must use the './operation.sh' script. The most
 279  common commands used for testing are:
 280
 281  - Enable reports dump for failed tests: ./operation.sh "test|report|failed"
 282  - Launch traffic: ./operation.sh "test|ttps|<test ticks per second (*)>"
 283
 284    (*) this is related to a single instance, because operation script launched
 285        here invokes every 'ADMLS/ADML-<instance>/operation.sh' counterpart
 286        script. Then, you should divide the desired CPS by the number of
 287        instances. For example, if you need $DESIRED_RATE test cases per second,
 288        as you have $ADML_INSTANCES instances, then you should execute:
 289
 290         ./operation.sh "test|ttps|$RATE_PER_INSTANCE"
 291
 292  - Stop traffic: ./operation.sh "test|ttps|0"
 293  - Reset already classified (Success/Failed) test cases: ./operation.sh "test|reset[|soft]"
 294  - Reset also 'in-progress' state test cases: ./operation.sh "test|reset|hard"
 295  - Clear programmed test cases: ./operation.sh "test|clear"
 296
 297 Remember that './operation.sh' broadcasts the operation scripts inside
 298  the ADML instances, then some operations should better be used within
 299  a specific 'ADMLS/ADML-<instance>' directory to avoid console spam:
 300
 301  - Check a testcase in runtime: ADMLS/ADML-001/operation.sh "test|look|<test id>"
 302  - Execute the next programmed test case: ADMLS/ADML-001/operation.sh "test|next"
 303  - Interactive-step execution: ADMLS/ADML-001/operation.sh "test|interact|<steps to execute>|<test id>"
 304  - Summary: ADMLS/ADML-001/operation.sh "test|summary"
 305
 306 For a complete and detailed information, execute: ./operation.sh --help | less
 307
 308 You could also use './launchCPS.sh' script.
 309
 310 EOF
 311
 312 fi
 313
 314 if [ -n "$start_testing" ]
 315 then
 316   echo
 317   echo "Start testing to achieve desired rate of $DESIRED_RATE test cases per second ..."
 318   echo
 319   ./operation.sh "test|ttps|$RATE_PER_INSTANCE"
 320 fi
 321
 322 echo
 323 echo "Done !"
 324 echo
 325