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=10
  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|<timeout ms>|<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|0|<initial sequence>|<final sequence>|7|CCR-I.xml|CCR-T.xml
  65
  66           which would be parsed for the specific ADML instance programmed:
  67
  68              dynamic|0|2000001|2001000|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 }
  93
  94 #############
  95 # EXECUTION #
  96 #############
  97 miss_conf=
  98 [ ! -f .st_conf_adml_instances ] && miss_conf=yes
  99 [ ! -f .st_conf_n_testcases_program_layout ] && miss_conf=yes
 100 [ ! -f .st_conf_cycle_repeats ] && miss_conf=yes
 101 [ ! -f .st_conf_rate_per_instance ] && miss_conf=yes
 102 [ ! -f .st_conf_desired_rate ] && miss_conf=yes
 103 [ -n "$miss_conf" ] && _exit "You must run './configure.sh' script firtly !!"
 104
 105 echo
 106 [ -z "$1" ] && usage
 107 echo "Testcases programming ..."
 108 echo
 109
 110 # We launch in background !
 111 #./operation.sh --ping >/dev/null
 112 #[ $? -ne 0 ] && _exit "Programming aborted (some ADML client process is not running) !"
 113
 114 # Arguments:
 115 PROG_TYPE=$1
 116 AUTOSTART=$2
 117
 118 # test case stuff programming #########################################################
 119 if [ "$PROG_TYPE" != "dynamic" ]
 120 then
 121   TESTCASE_DIR=$PROG_TYPE
 122
 123   [ ! -d $TESTCASE_DIR ] && _exit "Cannot found the test directory '$TESTCASE_DIR' !!"
 124   TESTCASE=( `ls $TESTCASE_DIR/testcase*msk 2>/dev/null` )
 125   TESTCASE_FILES=${#TESTCASE[@]}
 126   [ $TESTCASE_FILES -ne 1 ] && _exit "One and only one 'testcase*msk' file must be present !!"
 127
 128   MAX_NUMBER_GROUPS=$(grep ^MAX_NUMBER_GROUPS= clone.sh | cut -d= -f2)
 129   CLONE_GROUPS=$((MAX_NUMBER_GROUPS/ADML_INSTANCES))
 130   #CLONE_GROUPS=1
 131   specific=
 132   [ -f $TESTCASE_DIR/specific ] && specific=specific
 133
 134   count=0
 135   while read -r line
 136   do
 137     instance=$(echo $line | awk '{ print $1 }')
 138     ini_seq=$(echo $line | awk '{ print $2 }')
 139     fin_seq=$(echo $line | awk '{ print $3 }')
 140     ADML_DIR=`readlink -f ADMLS/ADML-$instance`
 141     echo -e "\rCloning interval [$ini_seq,$fin_seq] for $(basename $ADML_DIR) ..."
 142     ./clone.sh $ADML_DIR $TESTCASE $ini_seq $fin_seq $CLONE_GROUPS $specific &
 143     sleep 0.1
 144     count=$((count+1))
 145     if [ $count -eq $ADML_CONCURRENT_PROVISION_JOBS ]
 146     then
 147       wait $(jobs -p)
 148       count=0
 149     fi
 150
 151   done < $PROGRAM_LAYOUT_FILE
 152
 153   # Advice for idle cpu:
 154   advice_to_squeeze_idle_cpu
 155
 156   # Wait background jobs to finish:
 157   sleep 5
 158   echo "Waiting for clone completion ..."
 159   echo "(please be patient, this may take a while)"
 160   echo
 161   echo "Background Jobs: $(jobs -p | wc -l)"
 162   wait $(jobs -p)
 163
 164   echo
 165   echo "Programming has finished !"
 166   echo
 167
 168   echo "Configuring repeat cycles ..."
 169   ./operation.sh "test|repeats|$REPEATS"
 170
 171   if [ -n "$specific" ]
 172   then
 173     echo "A new file '$TESTCASE_DIR/specific.all' has been created."
 174     echo "Probably you need to apply it before starting traffic."
 175     echo
 176     echo "Press ENTER to continue, CTRL-C to abort ..."
 177     read dummy
 178   fi
 179
 180 # dynamic programming #################################################################
 181 else
 182   TESTCASE_DIR=$(readlink -f dynlibs/libanna_dynamicLauncherProcedure.so | xargs dirname)
 183   DYNAMIC_SUFFIX_FILE=$TESTCASE_DIR/dynamic.suffix
 184
 185   [ ! -f $DYNAMIC_SUFFIX_FILE ] && _exit "Missing '$DYNAMIC_SUFFIX_FILE' file.\nUse 'dynlibs/select.sh' to change the dynamic procedure and restart the ADML instances."
 186   dynamic_suffix=( $(grep -v ^# $DYNAMIC_SUFFIX_FILE) )
 187
 188   # Multiple scenarios:
 189   suffixes=${#dynamic_suffix[@]}
 190   if [ $suffixes -gt 1 ]
 191   then
 192     echo
 193     echo "----------------------------------------------------------------"
 194     cat $DYNAMIC_SUFFIX_FILE
 195     echo "----------------------------------------------------------------"
 196     echo
 197     echo "Detected $suffixes scenarios:"
 198     echo
 199     tmpfile=$(mktemp)
 200     opt=1
 201     for line in $(grep -v ^# $DYNAMIC_SUFFIX_FILE)
 202     do
 203       echo "${opt}) $line"
 204       opt=$((opt+1))
 205     done > $tmpfile
 206     cat $tmpfile
 207     echo
 208     echo "Select the desired option (0 to input a user defined one):"
 209     read option
 210     while [ -z "$option" ]; do read option ; done
 211     if [ "$option" != "0" ]
 212     then
 213       dynamic_suffix=$(grep "^${option}) " $tmpfile | cut -d" " -f2-)
 214       [ -z "$dynamic_suffix" ] && _exit "Invalid option !"
 215     else
 216       echo "Input specific program arguments:"
 217       echo " (be sure that are supported by the dynamic procedure)"
 218       echo
 219       read dynamic_suffix
 220       while [ -z "$dynamic_suffix" ]; do read dynamic_suffix ; done
 221     fi
 222   fi
 223
 224   # Modify xml files path:
 225   xmls=( $(echo $dynamic_suffix | sed 's/'\|'/ /g') )
 226   dynamic_suffix=$(for xml in ${xmls[@]}
 227   do
 228     echo $xml | grep -q "\.xml$"
 229     [ $? -eq 0 ] && echo -n "$TESTCASE_DIR/"
 230     echo -n "${xml}|"
 231   done | sed 's/'\|'$//')
 232
 233   # If still idle CPU, you could increase chunks number of background jobs
 234   echo "Dynamic programming ..."
 235   echo
 236   while read -r line
 237   do
 238     instance=$(echo $line | awk '{ print $1 }')
 239     ini_seq=$(echo $line | awk '{ print $2 }')
 240     fin_seq=$(echo $line | awk '{ print $3 }')
 241     ADML_DIR=`readlink -f ADMLS/ADML-$instance`
 242
 243     cd $ADML_DIR
 244     ./operation.sh -t 60 "dynamic|$ini_seq|$fin_seq|$dynamic_suffix" &
 245     sleep 0.1
 246     count=$((count+1))
 247     if [ $count -eq $ADML_CONCURRENT_PROVISION_JOBS ]
 248     then
 249       wait $(jobs -p)
 250       count=1
 251     fi
 252     cd - >/dev/null
 253
 254   done < $PROGRAM_LAYOUT_FILE
 255
 256   # Advice for idle cpu:
 257   advice_to_squeeze_idle_cpu
 258
 259 fi
 260
 261 echo
 262 echo
 263 start_testing=
 264 if [ "$AUTOSTART" = "-s" ]
 265 then
 266   start_testing=yes
 267 else
 268   cat << EOF
 269
 270 To start testing, you must use the './operation.sh' script. The most
 271  common commands used for testing are:
 272
 273  - Enable reports dump for failed tests: ./operation.sh "test|report|failed"
 274  - Launch traffic: ./operation.sh "test|ttps|<test ticks per second (*)>"
 275
 276    (*) this is related to a single instance, because operation script launched
 277        here invokes every 'ADMLS/ADML-<instance>/operation.sh' counterpart
 278        script. Then, you should divide the desired CPS by the number of
 279        instances. For example, if you need $DESIRED_RATE test cases per second,
 280        as you have $ADML_INSTANCES instances, then you should execute:
 281
 282         ./operation.sh "test|ttps|$RATE_PER_INSTANCE"
 283
 284  - Stop traffic: ./operation.sh "test|ttps|0"
 285  - Reset already classified (Success/Failed) test cases: ./operation.sh "test|reset[|soft]"
 286  - Reset also 'in-progress' state test cases: ./operation.sh "test|reset|hard"
 287  - Clear programmed test cases: ./operation.sh "test|clear"
 288
 289 Remember that './operation.sh' broadcasts the operation scripts inside
 290  the ADML instances, then some operations should better be used within
 291  a specific 'ADMLS/ADML-<instance>' directory to avoid console spam:
 292
 293  - Check a testcase in runtime: ADMLS/ADML-001/operation.sh "test|look|<test id>"
 294  - Execute the next programmed test case: ADMLS/ADML-001/operation.sh "test|next"
 295  - Interactive-step execution: ADMLS/ADML-001/operation.sh "test|interact|<steps to execute>|<test id>"
 296  - Summary: ADMLS/ADML-001/operation.sh "test|summary"
 297
 298 For a complete and detailed information, execute: ./operation.sh --help | less
 299
 300 You could also use './launchCPS.sh' script.
 301
 302 EOF
 303
 304 fi
 305
 306 if [ -n "$start_testing" ]
 307 then
 308   echo
 309   echo "Start testing to achieve desired rate of $DESIRED_RATE test cases per second ..."
 310   echo
 311   ./operation.sh "test|ttps|$RATE_PER_INSTANCE"
 312 fi
 313
 314 echo
 315 echo "Done !"
 316 echo
 317