qa/1052

   1 #!/bin/bash
   2 # PCP QA Test No. 1052
   3 # Exercise the JSON PMDA.
   4 #
   5 # Copyright (c) 2015 Red Hat.
   6 #
   7
   8 seq=`basename $0`
   9 echo "QA output created by $seq"
  10
  11 . ./common.python
  12
  13 python_path=`which $python`
  14 pmda_path="$PCP_PMDAS_DIR/json"
  15 pmda_script="${pmda_path}/pmdajson.python"
  16 pmda_config="${pmda_path}/config.json"
  17 ceph_script="${pmda_path}/generate_ceph_metadata"
  18 qa_dir=`pwd`
  19 json_qa_dir="${qa_dir}/json"
  20 pmda_config_dir="${PCP_VAR_DIR}/config/pmda"
  21 pmda_saved_config_dir="${pmda_config_dir}/pmdajson.$seq"
  22 test -f "$pmda_script" || _notrun "pmdajson not installed"
  23 $python -c "from pcp import pmda" >/dev/null 2>&1
  24 [ $? -eq 0 ] || _notrun "python pcp pmda module not installed"
  25 $python -c "import jsonpointer" >/dev/null 2>&1
  26 [ $? -eq 0 ] || _notrun "python jsonpointer module not installed"
  27 $python -c "import six" >/dev/null 2>&1
  28 [ $? -eq 0 ] || _notrun "python six module not installed"
  29
  30 status=1        # failure is the default!
  31 $sudo rm -rf $tmp.* $seq.full
  32 mkdir $tmp
  33 chmod ugo+rwx $tmp
  34 cd $tmp
  35
  36 # We need a bit more interaction with dbpmda than other tests do, so
  37 # create 2 named pipes (FIFOs). This allows us to send dbpmda some
  38 # commands, do some shell commands, then send the same dbpmda session
  39 # more commands.
  40 fifo_in="${tmp}/fifo_in"
  41 fifo_out="${tmp}/fifo_out"
  42 $sudo mkfifo ${fifo_in} ${fifo_out}
  43 $sudo chmod 666 ${fifo_in} ${fifo_out}
  44
  45 _needclean=true
  46 trap "cleanup; exit \$status" 0 1 2 3 15
  47
  48 # Notice in _drain_output() we are reading from fd 4, which will be
  49 # set up later to point one of the fifos we created above.
  50 _drain_output()
  51 {
  52     quit=0
  53     while [ $quit -eq 0 ]; do
  54         # detect failure, but have a last round
  55         read -u 4 -t 1 output || quit=1
  56         echo "$output" | _filter
  57     done
  58 }
  59
  60 # We have to sort the output of certain commands (like "children"),
  61 # since the order of the output depends on python internal ordering.
  62 _drain_output_sorted()
  63 {
  64     _drain_output | LC_COLLATE=POSIX sort
  65 }
  66
  67 _filter()
  68 {
  69     tee -a $here/$seq.full | \
  70     sed \
  71         -e "s;$PCP_PMDAS_DIR;\$PCP_PMDAS_DIR;" \
  72         -e '/pmResult/s/ .* numpmid/ ... numpmid/' \
  73         -e '/[0-9][0-9]:[0-9][0-9]:[0-9][0-9]/s/[^ ]*/TIMESTAMP/' \
  74         -e "s;$python_path;\$PCP_PYTHON_PROG;" \
  75         -e "s;$python;python;" \
  76         -e 's;137.3.[0-9]\+;137.3.ID;' \
  77     #end
  78 }
  79
  80 _filter2()
  81 {
  82     tee -a $here/$seq.full | \
  83     sed \
  84         -e '2,$s/^\([0-9][0-9]*\) [0-9][0-9]* /\1 TIMESTAMP /'
  85 }
  86
  87 cleanup()
  88 {
  89     cd $here
  90     if $_needclean; then
  91         _needclean=false
  92         _restore_config $PCP_PMCDCONF_PATH
  93         if [ -f ${pmda_config}.$seq ]; then
  94             _restore_config ${pmda_config}
  95         fi
  96
  97         # Remove the newly created indom cache files and restore any
  98         # old indom cache files.
  99         $sudo rm -f ${pmda_config_dir}/${domain}.*
 100         if [ -d ${pmda_saved_config_dir} ]; then
 101             $sudo mv ${pmda_saved_config_dir}/* ${pmda_config_dir}/
 102             $sudo rm -rf ${pmda_saved_config_dir}
 103         fi
 104     fi
 105     $sudo rm -rf $tmp $tmp.*
 106 }
 107
 108 domain=137
 109 test="$here/json"
 110
 111 # Copy the pmcd config file to restore state later.
 112 _save_config $PCP_PMCDCONF_PATH
 113
 114 # Ditto for JSON pmda config.
 115 if [ -f ${pmda_config} ]; then
 116     _save_config ${pmda_config}
 117 fi
 118
 119 # We want to get any JSON pmda indom cache files out of the way, so we
 120 # start with a clean slate. We'll restore these at the end.
 121 if [ -f "${pmda_config_dir}/${domain}.0" ]; then
 122     $sudo rm -rf ${pmda_saved_config_dir}
 123     $sudo mkdir ${pmda_saved_config_dir}
 124     $sudo mv ${pmda_config_dir}/${domain}.* ${pmda_saved_config_dir}/
 125 fi
 126
 127 # Create a new JSOM pmda config file and install it
 128 cat > ${tmp}/config.json << EOF
 129 {
 130     "directory_list" : [
 131         "${tmp}"
 132     ]
 133 }
 134 EOF
 135 $sudo cp ${tmp}/config.json ${pmda_config}
 136
 137 # Create some JSON data/metadata files.
 138 #
 139 # SRC1 is a basic JSON data/metadata files.
 140 SRC1_METADATA="${tmp}/s1_metadata.json"
 141 SRC1_DATA1="${tmp}/s1_data1.json"
 142 SRC1_DATA2="${tmp}/s1_data2.json"
 143 cat > ${SRC1_METADATA} <<EOF
 144 {
 145   "metrics": [
 146     {
 147       "name": "string",
 148       "pointer": "/string",
 149       "type": "string",
 150       "description": "Test string"
 151     },
 152     {
 153       "name": "value",
 154       "pointer": "/value",
 155       "type": "integer",
 156       "description": "Integer value",
 157       "semanatics": "instantaneous"
 158     },
 159     {
 160       "name": "counter",
 161       "pointer": "/counter",
 162       "type": "double",
 163       "description": "double counter",
 164       "semantics": "counter"
 165     },
 166     {
 167       "name": "discrete",
 168       "pointer": "/discrete",
 169       "type": "integer",
 170       "description": "discrete integer",
 171       "semantics": "discrete"
 172     }
 173   ]
 174 }
 175 EOF
 176 cat > ${SRC1_DATA1} <<EOF
 177 {
 178   "string": "original value",
 179   "value": 0,
 180   "counter": 5,
 181   "discrete": 7
 182 }
 183 EOF
 184 cat > ${SRC1_DATA2} <<EOF
 185 {
 186   "string": "new value",
 187   "value": 99,
 188   "counter": 10,
 189   "discrete": 14
 190 }
 191 EOF
 192
 193 # SRC2 is more complicated, and has an array.
 194 SRC2_METADATA="${tmp}/s2_metadata.json"
 195 SRC2_DATA1="${tmp}/s2_data1.json"
 196 SRC2_DATA2="${tmp}/s2_data2.json"
 197 SRC2_DATA3="${tmp}/s2_data3.json"
 198 SRC2_DATA4="${tmp}/s2_data4.json"
 199 cat > ${SRC2_METADATA} <<EOF
 200 {
 201   "metrics": [
 202     {
 203       "name": "array_data",
 204       "pointer": "/array_data",
 205       "type": "array",
 206       "index": "/__id",
 207       "metrics": [
 208         {
 209           "name": "count",
 210           "pointer": "/count",
 211           "type": "integer"
 212         },
 213         {
 214           "name": "value",
 215           "pointer": "/value",
 216           "type": "integer"
 217         },
 218         {
 219           "name": "counter",
 220           "pointer": "/counter",
 221           "type": "double",
 222           "semantics": "counter"
 223         }
 224       ]
 225     }
 226   ]
 227 }
 228 EOF
 229 cat > ${SRC2_DATA1} <<EOF
 230 {
 231   "array_data": [
 232     {
 233       "__id": "first",
 234       "count": 0,
 235       "value": 1024,
 236       "counter": 3
 237     },
 238     {
 239       "__id": "second",
 240       "count": 99,
 241       "value": 2048,
 242       "counter": 5
 243     }
 244   ]
 245 }
 246 EOF
 247 cat > ${SRC2_DATA2} <<EOF
 248 {
 249   "array_data": [
 250     {
 251       "__id": "third",
 252       "count": 3,
 253       "value": 3072,
 254       "counter": 7
 255     },
 256     {
 257       "__id": "second",
 258       "count": 100,
 259       "value": 2049,
 260       "counter": 10
 261     }
 262   ]
 263 }
 264 EOF
 265 cat > ${SRC2_DATA3} <<EOF
 266 {
 267   "array_data": [
 268     {
 269       "__id": "first",
 270       "count": 1,
 271       "value": 1025,
 272       "counter": 6
 273     },
 274     {
 275       "__id": "fourth",
 276       "count": 4,
 277       "value": 999,
 278       "counter": 13
 279     }
 280   ]
 281 }
 282 EOF
 283 cat > ${SRC2_DATA4} <<EOF
 284 {
 285   "array_data": [
 286     {
 287       "__id": "first",
 288       "count": 2,
 289       "value": 1026,
 290       "counter": 9
 291     }
 292   ]
 293 }
 294 EOF
 295
 296 #
 297 # real QA test starts here
 298 #
 299
 300 pmns_root="${tmp}/json.root"
 301 PCP_PYTHON_PMNS=root $python "$pmda_script" > ${pmns_root}
 302
 303 # Start dbpmda in the background, redirecting its stdin/stdout to the
 304 # fifos.
 305 cd $here        # create pmda log file somewhere safe (for debugging)
 306 $sudo dbpmda -n ${pmns_root} -ie <${fifo_in} >${fifo_out} 2>&1 &
 307
 308 # Open fd 3 for write and fd 4 for read. Note that we need to avoid
 309 # closing either fifo below, so we have to be careful with redirects.
 310 exec 3>${fifo_in} 4<${fifo_out}
 311
 312 # Check to see if the 'nsources' static metric is present.
 313 cat >&3 <<EOF
 314 open pipe $python_path $pmda_script
 315 getdesc on
 316 desc json.nsources
 317 fetch json.nsources
 318 EOF
 319 _drain_output
 320
 321 cat >&3 <<EOF
 322 children json
 323 EOF
 324 _drain_output_sorted
 325
 326 # Now, let's add a JSON data source.
 327 mkdir ${tmp}/s1
 328 cp $SRC1_METADATA ${tmp}/s1/metadata.json
 329 cp $SRC1_DATA1 ${tmp}/s1/data.json
 330
 331 # On this fetch, the 'nsources' static metric should be increased and
 332 # the new data source should be present.
 333 cat >&3 <<EOF
 334 fetch json.nsources
 335 EOF
 336
 337 cat >&3 <<EOF
 338 children json
 339 children json.s1
 340 EOF
 341 _drain_output_sorted
 342
 343 cat >&3 <<EOF
 344 desc json.s1.counter
 345 desc json.s1.discrete
 346 fetch json.s1.string
 347 fetch json.s1.value
 348 fetch json.s1.counter
 349 fetch json.s1.discrete
 350 EOF
 351 _drain_output
 352
 353 # Now update the JSON data for the source.
 354 cp $SRC1_DATA2 ${tmp}/s1/data.json
 355
 356 # On this fetch, the data source variables should have their new values.
 357 cat >&3 <<EOF
 358 fetch json.nsources
 359 fetch json.s1.string
 360 fetch json.s1.value
 361 fetch json.s1.counter
 362 fetch json.s1.discrete
 363 EOF
 364 _drain_output
 365
 366 # Add the 2nd JSON data source.
 367 mkdir ${tmp}/s2
 368 cp $SRC2_METADATA ${tmp}/s2/metadata.json
 369 cp $SRC2_DATA1 ${tmp}/s2/data.json
 370
 371 # On this fetch, the 'nsources' static metric should be increased and
 372 # the new data source should be present.
 373 cat >&3 <<EOF
 374 fetch json.nsources
 375 EOF
 376 _drain_output
 377
 378 cat >&3 <<EOF
 379 children json
 380 children json.s1
 381 children json.s2
 382 EOF
 383 _drain_output_sorted
 384
 385 cat >&3 <<EOF
 386 instance $domain.0
 387 desc json.s2.array_data.counter
 388 fetch json.s2.array_data.count
 389 fetch json.s2.array_data.value
 390 fetch json.s2.array_data.counter
 391 EOF
 392 _drain_output
 393
 394 # Let's test proper indom support with the 2nd source. First, find out
 395 # what the current indom state looks like.
 396 cat ${pmda_config_dir}/${domain}.4 | _filter2
 397 cat >&3 <<EOF
 398 instance $domain.4
 399 EOF
 400 _drain_output
 401
 402 # Copy a new data file in and see how the instance values change. The
 403 # instance command just returns "active" instances, not all instances.
 404 cp $SRC2_DATA2 ${tmp}/s2/data.json
 405 cat >&3 <<EOF
 406 fetch json.s2.array_data.count
 407 fetch json.s2.array_data.value
 408 fetch json.s2.array_data.counter
 409 instance $domain.4
 410 EOF
 411 _drain_output
 412 # We should see all instances by looking at the indom cache file.
 413 cat ${pmda_config_dir}/${domain}.4 | _filter2
 414
 415 # Let's try another indom test. This data file reuses an inactive
 416 # instance and adds a new one.
 417 cp $SRC2_DATA3 ${tmp}/s2/data.json
 418 cat >&3 <<EOF
 419 fetch json.s2.array_data.count
 420 fetch json.s2.array_data.value
 421 fetch json.s2.array_data.counter
 422 instance $domain.4
 423 EOF
 424 _drain_output
 425 # We should see all instances by looking at the indom cache file.
 426 cat ${pmda_config_dir}/${domain}.4 | _filter2
 427
 428 # Let's try another indom test. This data file just reuses an
 429 # instance.
 430 cp $SRC2_DATA4 ${tmp}/s2/data.json
 431 cat >&3 <<EOF
 432 fetch json.s2.array_data.count
 433 fetch json.s2.array_data.value
 434 fetch json.s2.array_data.counter
 435 instance $domain.4
 436 EOF
 437 _drain_output
 438 # We should see all instances by looking at the indom cache file.
 439 cat ${pmda_config_dir}/${domain}.4 | _filter2
 440
 441 # Let's test the ceph support by running the 'generate_ceph_metadata'
 442 # script on some canned data.
 443 mkdir -p ${tmp}/ceph
 444 cp ${json_qa_dir}/ceph_data1.json ${tmp}/ceph/data.json
 445 # Use the generate_ceph_metadata script to convert the ceph schema
 446 # into metadata.
 447 $python ${ceph_script} -o ${tmp}/ceph/metadata.json -t ${json_qa_dir}/ceph_schema1.json
 448
 449 # On this fetch, the 'nsources' static metric should be increased and
 450 # the new data source should be present. Notice we aren't grabbing all
 451 # the metrics from the ceph source, just a couple.
 452 cat >&3 <<EOF
 453 fetch json.nsources
 454 EOF
 455 _drain_output
 456
 457 cat >&3 <<EOF
 458 children json
 459 children json.s1
 460 children json.s2
 461 children json.ceph
 462 EOF
 463 _drain_output_sorted
 464
 465 cat >&3 <<EOF
 466 instance $domain.0
 467 fetch json.ceph.filestore.journal_wr_bytes.sum
 468 fetch json.ceph.osd.stat_bytes
 469 EOF
 470 _drain_output
 471
 472 # Other things to test:
 473 # - 'prefix' directive
 474 # - 'data-exec' directive
 475
 476 # Tell dbpmda to quit.
 477 cat >&3 <<EOF
 478 quit
 479 EOF
 480 _drain_output
 481
 482 # Wait for dbpmda to quit.
 483 wait
 484
 485 status=0
 486 exit