diff --git a/tests/.gitignore b/tests/.gitignore new file mode 100644 index 0000000..e6c79fd --- /dev/null +++ b/tests/.gitignore @@ -0,0 +1,3 @@ +# Ignore tests runs/artefacts. +artifacts/** +**/*.retry diff --git a/tests/smoke/runtest.sh b/tests/smoke/runtest.sh new file mode 100644 index 0000000..9fd5e68 --- /dev/null +++ b/tests/smoke/runtest.sh @@ -0,0 +1,623 @@ +#!/bin/bash + +# This file was autogenerated at 2019-05-13T13:43:38+02:00 from 90bd97ada89befa1a63133335a419ad7311c3d75 + +# Copyright (c) 2019, Red Hat, Inc. +# +# Permission to use, copy, modify, and/or distribute this software for any +# purpose with or without fee is hereby granted, provided that the above +# copyright notice and this permission notice appear in all copies. +# +# THE SOFTWARE IS PROVIDED "AS IS" AND RED HAT, INC. DISCLAIMS ALL WARRANTIES +# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL RED HAT, INC. BE LIABLE +# FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +# OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +# +# Author: Jan Friesse + + +# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +# !!! Script overwrites corosync.conf, authkey and qdevice/qnetd certificates !!! +# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + +# Home https://github.com/jfriesse/csts/tree/master/smoke + +# -e is really important +set -xe +set -o pipefail + +# Variables changing test behavior +PREFIX="/" + +COROSYNC_SYSCONFD="${PREFIX}etc/corosync" +COROSYNC_CONF="${COROSYNC_SYSCONFD}/corosync.conf" +COROSYNC_AUTHKEY="${COROSYNC_SYSCONFD}/authkey" +COROSYNC_CLUSTER_NAME="smoketestcluster" + +TOKEN_TIMEOUT=1000 +MAX_REPEATS=60 + +#################### +# Helper functions # +#################### +get_ip() { + ip_res=$(ip route get 8.8.8.8) + # Format is "8.8.8.8 via ROUTE_IPADDR dev DEV src IPADDR uid NUMBER" + # Remove everything up to "src " and then everything after " " + addr=${ip_res##*src } + addr=${addr%% *} + + echo "$addr" +} + +# generate_corosync_conf crypto [token] [qdevice] +# crypto can be on or off +# when token is defined it is used for token timeout +# when qdevice is set to on qdevice section is created and second node is added +generate_corosync_conf() { + case "$1" in + "on") + cipher="aes256" + hash="sha256" + ;; + "off") + cipher="none" + hash="none" + ;; + *) + # Unknown crypto + exit 1 + esac + + token=$TOKEN_TIMEOUT + if [ ! -z "$2" ];then + token="$2" + fi + qdevice="$3" + true_command=`which true` + +cat << _EOF_ + totem { + version: 2 + cluster_name: $COROSYNC_CLUSTER_NAME + transport: knet + crypto_cipher: $cipher + crypto_hash: $hash + token: $token + } + + logging { + to_logfile: yes + logfile: /var/log/cluster/corosync.log + to_syslog: yes + } + + quorum { + provider: corosync_votequorum +_EOF_ + + if [ "$qdevice" == "on" ];then +cat << _EOF_ + device { + votes: 1 + model: net + net { + host: $LOCAL_IP + algorithm: ffsplit + } + heuristics { + mode: sync + exec_true: $true_command + } + } +_EOF_ + fi + +cat << _EOF_ + } + + nodelist { + node { + nodeid: 1 + ring0_addr: $LOCAL_IP + } +_EOF_ + + if [ "$qdevice" == "on" ];then +cat << _EOF_ + node { + nodeid: 2 + ring0_addr: 192.0.2.2 + } +_EOF_ + fi + +cat << _EOF_ + } +_EOF_ +} + +# service_start service +service_start() { + # service service must be inactive + systemctl is-active "$1" && exit 1 || true + + systemctl start "$1" + + systemctl is-active "$1" +} + +# service_stop service +service_stop() { + systemctl is-active "$1" || exit 1 + + systemctl stop "$1" + + systemctl is-active "$1" && exit 1 || true +} + +###################### +# Computed variables # +###################### +LOCAL_IP=$(get_ip) + +################## +# C test sources # +################## + +# Test sources are encoded as a base64 string and piped to base64 to store them in /tmp +# corosync-api-test.c +echo "LyoKICogQ29weXJpZ2h0IChjKSAyMDE5LCBSZWQgSGF0LCBJbmMuCiAqCiAqIFBlcm1pc3Npb24g +dG8gdXNlLCBjb3B5LCBtb2RpZnksIGFuZC9vciBkaXN0cmlidXRlIHRoaXMgc29mdHdhcmUgZm9y +IGFueQogKiBwdXJwb3NlIHdpdGggb3Igd2l0aG91dCBmZWUgaXMgaGVyZWJ5IGdyYW50ZWQsIHBy +b3ZpZGVkIHRoYXQgdGhlIGFib3ZlCiAqIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlz +c2lvbiBub3RpY2UgYXBwZWFyIGluIGFsbCBjb3BpZXMuCiAqCiAqIFRIRSBTT0ZUV0FSRSBJUyBQ +Uk9WSURFRCAiQVMgSVMiIEFORCBSRUQgSEFULCBJTkMuIERJU0NMQUlNUyBBTEwgV0FSUkFOVElF +UwogKiBXSVRIIFJFR0FSRCBUTyBUSElTIFNPRlRXQVJFIElOQ0xVRElORyBBTEwgSU1QTElFRCBX +QVJSQU5USUVTCiAqIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUy4gSU4gTk8gRVZFTlQg +U0hBTEwgUkVEIEhBVCwgSU5DLiBCRSBMSUFCTEUKICogRk9SIEFOWSBTUEVDSUFMLCBESVJFQ1Qs +IElORElSRUNULCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgT1IgQU5ZIERBTUFHRVMKICogV0hB +VFNPRVZFUiBSRVNVTFRJTkcgRlJPTSBMT1NTIE9GIFVTRSwgREFUQSBPUiBQUk9GSVRTLCBXSEVU +SEVSIElOIEFOIEFDVElPTgogKiBPRiBDT05UUkFDVCwgTkVHTElHRU5DRSBPUiBPVEhFUiBUT1JU +SU9VUyBBQ1RJT04sIEFSSVNJTkcgT1VUIE9GIE9SIElOCiAqIENPTk5FQ1RJT04gV0lUSCBUSEUg +VVNFIE9SIFBFUkZPUk1BTkNFIE9GIFRISVMgU09GVFdBUkUuCiAqCiAqIEF1dGhvcjogSmFuIEZy +aWVzc2UgPGpmcmllc3NlQHJlZGhhdC5jb20+CiAqLwoKLyoKICogU2ltcGxlIHRlc3Qgb2YgQ1BH +IGNhbGxiYWNrcy4gUHJvZ3JhbSBpbml0aWFsbHkgam9pbnMgQ1BHIGdyb3VwLCB3YWl0cyBmb3IK +ICogY3BnX2NvbmZjaGcgYW5kIGNwZ190b3RlbV9jb25mY2hnIGNhbGxiYWNrcyBhbmQgdGhlbiBz +dGFydHMgbG9vcCBvZiBzZW5kaW5nCiAqIGFuZCB3YWl0aW5nIGZvciB0aGUgbWVzc2FnZS4gTWVz +c2FnZSBoYXMgcmFuZG9tIGxlbmd0aCAodXAtdG8gTUFYX01TR19MRU4pCiAqIGFuZCByYW5kb20g +Y29udGVudC4gcmFuZF9yIGlzIHVzZWQgZm9yIHJhbmRvbSBudW1iZXIgZ2VuZXJhdGluZy4gTWVz +c2FnZQogKiBpcyBjaGVja2VkIG9uIGRlbGl2ZXJ5IGJ5IGlzc3Vpbmcgc2FtZSByYW5kX3IuIFNl +ZWQgZm9yIHJhbmRfciBhcmUKICogc3RvcmVkIGluIHNlbnRfcmFuZF9zZWVkIGFuZCByZWNlaXZl +ZF9yYW5kX3NlZWQgdmFyaWFibGVzLgogKgogKiBUaGlzIHRlc3QgY2hlY2tzIGZvbGxvd2luZyBD +UEcgcHJvcGVydGllczoKICogLSBQcm9jZXNzIGNhbiBqb2luIENQRyBncm91cAogKiAtIEJvdGgg +Y3BnX2NvbmZjaGcgYW5kIGNwZ190b3RlbV9jb25mY2hnIGNhbGxiYWNrcyBhcmUgcmVjZWl2ZWQg +d2l0aAogKiAgIG9ubHkgb25lIG5vZGUgYW5kIG9ubHkgb25lIHByb2Nlc3MgaW4gdGhlcmUKICog +LSBNZXNzYWdlcyBhcmUgc2VudCBhbmQgcmVjZWl2ZWQgd2l0aG91dCBhbnkgY29ycnVwdGlvbgog +Ki8KCiNpbmNsdWRlIDxzeXMvdHlwZXMuaD4KI2luY2x1ZGUgPHN5cy9zb2NrZXQuaD4KCiNpbmNs +dWRlIDxhc3NlcnQuaD4KI2luY2x1ZGUgPGVycm5vLmg+CiNpbmNsdWRlIDxpbnR0eXBlcy5oPgoj +aW5jbHVkZSA8cG9sbC5oPgojaW5jbHVkZSA8c3RkaW8uaD4KI2luY2x1ZGUgPHN0ZGxpYi5oPgoj +aW5jbHVkZSA8c3RyaW5nLmg+CiNpbmNsdWRlIDx1bmlzdGQuaD4KCiNpbmNsdWRlIDxjb3Jvc3lu +Yy9jb3JvdHlwZXMuaD4KI2luY2x1ZGUgPGNvcm9zeW5jL2NwZy5oPgoKLyoKICogUHJlZGVmaW5l +ZCB0ZXN0IGNvbnN0YW50cwogKi8KI2RlZmluZSBURVNUX05PREVJRAkJMQojZGVmaW5lIFRFU1Rf +R1JPVVBfTkFNRQkJInNtb2tlLWFwaS10ZXN0LWNwZy1ncm91cCIKI2RlZmluZSBNQVhfUkVUUklF +UwkJMzAKI2RlZmluZSBNQVhfTVNHX0xFTgkJKDEwMjQgKiAxMjgpCiNkZWZpbmUgTUVTU0FHRVNf +VE9fU0VOVAkxMjgKCi8qCiAqIFVzZWZ1bCBtYWNyb3MKICovCiNkZWZpbmUgY3NfcmVwZWF0KGNv +ZGUpIGRvIHsJCQkJXAoJaW50IGNzX3JlcGVhdF9jb3VudGVyID0gMDsJCQlcCglkbyB7CQkJCQkJ +XAoJCWlmICgoY29kZSkgPT0gQ1NfRVJSX1RSWV9BR0FJTikgewlcCgkJCWNzX3JlcGVhdF9jb3Vu +dGVyKys7CQlcCgkJCXBvbGwoTlVMTCwgMCwgMTAwMCk7CQlcCgkJfSBlbHNlIHsJCQkJXAoJCQli +cmVhazsJCQkJXAoJCX0JCQkJCVwKCX0gd2hpbGUgKGNzX3JlcGVhdF9jb3VudGVyIDwgTUFYX1JF +VFJJRVMpOwlcCn0gd2hpbGUgKDApCgojaWZuZGVmIElORlRJTQojZGVmaW5lIElORlRJTQkJCS0x +CiNlbmRpZgoKI2RlZmluZSBFTlRFUigpIHByaW50ZigiKyAlczoldSAlc1xuIiwgX19GSUxFX18s +IF9fTElORV9fLCBfX2Z1bmNfXykKI2RlZmluZSBMRUFWRSgpIHByaW50ZigiLSAlczoldSAlc1xu +IiwgX19GSUxFX18sIF9fTElORV9fLCBfX2Z1bmNfXykKCnN0YXRpYyBpbnQgY3BnX2NvbmZjaGdf +cmVjZWl2ZWQgPSAwOwpzdGF0aWMgaW50IGNwZ190b3RlbV9jb25mY2hnX3JlY2VpdmVkID0gMDsK +Ci8qCiAqIGJvdGggcmFuZCBzZWVkcyBtdXN0IGJlIGluIHN5bmMKICovCnN0YXRpYyB1bnNpZ25l +ZCBpbnQgc2VudF9yYW5kX3NlZWQgPSAwOwpzdGF0aWMgdW5zaWduZWQgaW50IHJlY2VpdmVkX3Jh +bmRfc2VlZCA9IDA7CnN0YXRpYyB1aW50MzJfdCBzZW50X21zZ19zZXFfbm8gPSAwOwpzdGF0aWMg +dWludDMyX3QgcmVjZWl2ZWRfbXNnX3NlcV9ubyA9IDA7CgpzdHJ1Y3QgdGVzdF9tc2cgewoJdWlu +dDMyX3Qgc2VxX25vIF9fYXR0cmlidXRlX18gKChhbGlnbmVkICg4KSkpOwoJdWludDMyX3QgZGF0 +YV9sZW4gX19hdHRyaWJ1dGVfXyAoKGFsaWduZWQgKDgpKSk7Cgl1bnNpZ25lZCBjaGFyIGRhdGFb +MF0gX19hdHRyaWJ1dGVfXyAoKGFsaWduZWQgKDgpKSk7Cn07CgpzdGF0aWMgdm9pZApEZWxpdmVy +Q2FsbGJhY2soY3BnX2hhbmRsZV90IGhhbmRsZSwKICAgIGNvbnN0IHN0cnVjdCBjcGdfbmFtZSAq +Z3JvdXBOYW1lLAogICAgdWludDMyX3Qgbm9kZWlkLAogICAgdWludDMyX3QgcGlkLAogICAgdm9p +ZCAqY3BnX21zZywKICAgIHNpemVfdCBjcGdfbXNnX2xlbikKewoJc3RydWN0IHRlc3RfbXNnICpt +c2c7Cgl1aW50MzJfdCB1MzI7CgoJRU5URVIoKTsKCglhc3NlcnQobm9kZWlkID09IFRFU1RfTk9E +RUlEKTsKCWFzc2VydChwaWQgPT0gZ2V0cGlkKCkpOwoKCWFzc2VydChjcGdfbXNnX2xlbiA+PSBz +aXplb2Yoc3RydWN0IHRlc3RfbXNnKSk7CgoJbXNnID0gKHN0cnVjdCB0ZXN0X21zZyAqKWNwZ19t +c2c7Cglhc3NlcnQobXNnLT5zZXFfbm8gPT0gcmVjZWl2ZWRfbXNnX3NlcV9ubyk7CglyZWNlaXZl +ZF9tc2dfc2VxX25vKys7CgoJYXNzZXJ0KGNwZ19tc2dfbGVuID09IG1zZy0+ZGF0YV9sZW4gKyBz +aXplb2Yoc3RydWN0IHRlc3RfbXNnKSk7CgoJLyoKCSAqIE1lc3NhZ2UgaGFzIGV4cGVjdGVkIGxl +bmd0aCBhbmQgY29udGVudAoJICovCglhc3NlcnQobXNnLT5kYXRhX2xlbiA9PSAodWludDMyX3Qp +KHJhbmRfcigmcmVjZWl2ZWRfcmFuZF9zZWVkKSAlIE1BWF9NU0dfTEVOKSk7CgoJZm9yICh1MzIg +PSAwOyB1MzIgPCBtc2ctPmRhdGFfbGVuOyB1MzIrKykgewoJCWFzc2VydChtc2ctPmRhdGFbdTMy +XSA9PSAodW5zaWduZWQgY2hhcilyYW5kX3IoJnJlY2VpdmVkX3JhbmRfc2VlZCkpOwoJfQoKCUxF +QVZFKCk7Cn0KCnN0YXRpYyB2b2lkClRvdGVtQ29uZmNoZ0NhbGxiYWNrKGNwZ19oYW5kbGVfdCBo +YW5kbGUsCiAgICBzdHJ1Y3QgY3BnX3JpbmdfaWQgcmluZ19pZCwKICAgIHVpbnQzMl90IG1lbWJl +cl9saXN0X2VudHJpZXMsCiAgICBjb25zdCB1aW50MzJfdCAqbWVtYmVyX2xpc3QpCnsKCglFTlRF +UigpOwoKCWFzc2VydChtZW1iZXJfbGlzdF9lbnRyaWVzID09IDEpOwoJYXNzZXJ0KG1lbWJlcl9s +aXN0WzBdID09IFRFU1RfTk9ERUlEKTsKCgljcGdfdG90ZW1fY29uZmNoZ19yZWNlaXZlZCA9IDE7 +CgoJTEVBVkUoKTsKfQoKc3RhdGljIHZvaWQKQ29uZmNoZ0NhbGxiYWNrKGNwZ19oYW5kbGVfdCBo +YW5kbGUsCiAgICBjb25zdCBzdHJ1Y3QgY3BnX25hbWUgKmdyb3VwX25hbWUsCiAgICBjb25zdCBz +dHJ1Y3QgY3BnX2FkZHJlc3MgKm1lbWJlcl9saXN0LCBzaXplX3QgbWVtYmVyX2xpc3RfZW50cmll +cywKICAgIGNvbnN0IHN0cnVjdCBjcGdfYWRkcmVzcyAqbGVmdF9saXN0LCBzaXplX3QgbGVmdF9s +aXN0X2VudHJpZXMsCiAgICBjb25zdCBzdHJ1Y3QgY3BnX2FkZHJlc3MgKmpvaW5lZF9saXN0LCBz +aXplX3Qgam9pbmVkX2xpc3RfZW50cmllcykKewoKCUVOVEVSKCk7CgoJYXNzZXJ0KGdyb3VwX25h +bWUtPmxlbmd0aCA9PSBzdHJsZW4oVEVTVF9HUk9VUF9OQU1FKSk7Cglhc3NlcnQobWVtY21wKGdy +b3VwX25hbWUtPnZhbHVlLCBURVNUX0dST1VQX05BTUUsIHN0cmxlbihURVNUX0dST1VQX05BTUUp +KSA9PSAwKTsKCWFzc2VydChtZW1iZXJfbGlzdF9lbnRyaWVzID09IDEpOwoJYXNzZXJ0KG1lbWJl +cl9saXN0WzBdLm5vZGVpZCA9PSBURVNUX05PREVJRCk7Cglhc3NlcnQobWVtYmVyX2xpc3RbMF0u +cGlkID09IGdldHBpZCgpKTsKCgljcGdfY29uZmNoZ19yZWNlaXZlZCA9IDE7CgoJTEVBVkUoKTsK +fQoKc3RhdGljIGNwZ19tb2RlbF92MV9kYXRhX3QgbW9kZWxfZGF0YSA9IHsKCS5jcGdfZGVsaXZl +cl9mbiA9CURlbGl2ZXJDYWxsYmFjaywKCS5jcGdfY29uZmNoZ19mbiA9CUNvbmZjaGdDYWxsYmFj +aywKCS5jcGdfdG90ZW1fY29uZmNoZ19mbiA9CVRvdGVtQ29uZmNoZ0NhbGxiYWNrLAoJLmZsYWdz +ID0JCUNQR19NT0RFTF9WMV9ERUxJVkVSX0lOSVRJQUxfVE9URU1fQ09ORiwKfTsKCnN0YXRpYyB2 +b2lkCnNlbmRfbXNnKGNwZ19oYW5kbGVfdCBjcGdfaGFuZGxlKQp7CglzdHJ1Y3QgdGVzdF9tc2cg +bXNnOwoJdW5zaWduZWQgY2hhciAqZGF0YTsKCXVpbnQzMl90IHUzMjsKCXN0cnVjdCBpb3ZlYyBp +b3ZbMl07Cgljc19lcnJvcl90IGNzX3JlczsKCglFTlRFUigpOwoKCW1zZy5kYXRhX2xlbiA9IHJh +bmRfcigmc2VudF9yYW5kX3NlZWQpICUgTUFYX01TR19MRU47Cgltc2cuc2VxX25vID0gc2VudF9t +c2dfc2VxX25vOwoKCXNlbnRfbXNnX3NlcV9ubysrOwoKCWRhdGEgPSBtYWxsb2Moc2l6ZW9mKHVu +c2lnbmVkIGNoYXIpICogbXNnLmRhdGFfbGVuKTsKCWFzc2VydChkYXRhICE9IE5VTEwpOwoKCWZv +ciAodTMyID0gMDsgdTMyIDwgbXNnLmRhdGFfbGVuOyB1MzIrKykgewoJCWRhdGFbdTMyXSA9ICh1 +bnNpZ25lZCBjaGFyKXJhbmRfcigmc2VudF9yYW5kX3NlZWQpOwoJfQoKCWlvdlswXS5pb3ZfYmFz +ZSA9ICh2b2lkICopJm1zZzsKCWlvdlswXS5pb3ZfbGVuID0gc2l6ZW9mKG1zZyk7Cglpb3ZbMV0u +aW92X2Jhc2UgPSAodm9pZCAqKWRhdGE7Cglpb3ZbMV0uaW92X2xlbiA9IG1zZy5kYXRhX2xlbjsK +Cgljc19yZXMgPSBjcGdfbWNhc3Rfam9pbmVkKGNwZ19oYW5kbGUsIENQR19UWVBFX0FHUkVFRCwg +aW92LCAyKTsKCWFzc2VydChjc19yZXMgPT0gQ1NfT0spOwoKCWZyZWUoZGF0YSk7CgoJTEVBVkUo +KTsKfQoKc3RhdGljIHZvaWQKdGVzdF9jcGcodm9pZCkKewoJY3BnX2hhbmRsZV90IGNwZ19oYW5k +bGU7CglzdHJ1Y3QgY3BnX25hbWUgZ3JvdXBfbmFtZTsKCWNzX2Vycm9yX3QgY3NfcmVzOwoJdW5z +aWduZWQgaW50IGxvY2FsX25vZGVpZDsKCWludCBjcGdfZmQ7CglzdHJ1Y3QgcG9sbGZkIHBmZDsK +CWludCBwb2xsX3JlczsKCWludCBzdGF0ZTsKCWludCBjb250OwoKCUVOVEVSKCk7CgoJc3RhdGUg +PSAwOwoKCXN0cmNweShncm91cF9uYW1lLnZhbHVlLCBURVNUX0dST1VQX05BTUUpOwoJZ3JvdXBf +bmFtZS5sZW5ndGggPSBzdHJsZW4oVEVTVF9HUk9VUF9OQU1FKTsKCgljc19yZXBlYXQoY3NfcmVz +ID0gY3BnX21vZGVsX2luaXRpYWxpemUoJmNwZ19oYW5kbGUsIENQR19NT0RFTF9WMSwKCSAgICAo +Y3BnX21vZGVsX2RhdGFfdCAqKSZtb2RlbF9kYXRhLCBOVUxMKSk7Cglhc3NlcnQoY3NfcmVzID09 +IENTX09LKTsKCgljc19yZXBlYXQoY3NfcmVzID0gY3BnX2pvaW4oY3BnX2hhbmRsZSwgJmdyb3Vw +X25hbWUpKTsKCWFzc2VydChjc19yZXMgPT0gQ1NfT0spOwoKCWNzX3JlcGVhdChjc19yZXMgPSBj +cGdfbG9jYWxfZ2V0KGNwZ19oYW5kbGUsICZsb2NhbF9ub2RlaWQpKTsKCWFzc2VydChjc19yZXMg +PT0gQ1NfT0spOwoJYXNzZXJ0KGxvY2FsX25vZGVpZCA9PSBURVNUX05PREVJRCk7CgoJY3NfcmVw +ZWF0KGNzX3JlcyA9IGNwZ19mZF9nZXQoY3BnX2hhbmRsZSwgJmNwZ19mZCkpOwoJYXNzZXJ0KGNz +X3JlcyA9PSBDU19PSyk7CgoJY29udCA9IDE7CgoJZG8gewoJCXBmZC5mZCA9IGNwZ19mZDsKCQlw +ZmQuZXZlbnRzID0gUE9MTElOOwoJCXBmZC5yZXZlbnRzID0gMDsKCgkJcG9sbF9yZXMgPSBwb2xs +KCZwZmQsIDEsIElORlRJTSk7CgkJaWYgKHBvbGxfcmVzID09IC0xKSB7CgkJCXBlcnJvcigicG9s +bF9yZXMgPT0gLTEiKTsKCQl9CgoJCWFzc2VydChwb2xsX3JlcyAhPSAwKTsKCQlhc3NlcnQocGZk +LnJldmVudHMgJiBQT0xMSU4pOwoKCQljc19yZXBlYXQoY3NfcmVzID0gY3BnX2Rpc3BhdGNoKGNw +Z19oYW5kbGUsIENTX0RJU1BBVENIX0FMTCkpOwoJCWFzc2VydChjc19yZXMgPT0gQ1NfT0spOwoK +CQlzd2l0Y2ggKHN0YXRlKSB7CgkJY2FzZSAwOgoJCQkvKgoJCQkgKiBXYWl0aW5nIGZvciBjcGdf +Y29uZmNoZ19yZWNlaXZlZCBhbmQgY3BnX3RvdGVtX2NvbmZjaGdfcmVjZWl2ZWQKCQkJICovCgkJ +CWlmIChjcGdfY29uZmNoZ19yZWNlaXZlZCAmJiBjcGdfdG90ZW1fY29uZmNoZ19yZWNlaXZlZCkg +ewoJCQkJLyoKCQkJCSAqIFNlbmQgZmlyc3QgbWVzc2FnZSBhbmQgd2FpdCBmb3IgaXQgaW4gbmV4 +dCBzdGF0ZQoJCQkJICovCgkJCQlzZW5kX21zZyhjcGdfaGFuZGxlKTsKCQkJCXN0YXRlID0gMTsK +CQkJfQoJCQlicmVhazsKCQljYXNlIDE6CgkJCWlmIChyZWNlaXZlZF9tc2dfc2VxX25vID49IE1F +U1NBR0VTX1RPX1NFTlQpIHsKCQkJCWNvbnQgPSAwOwoJCQl9IGVsc2UgIGlmIChyZWNlaXZlZF9t +c2dfc2VxX25vID09IHNlbnRfbXNnX3NlcV9ubykgewoJCQkJLyoKCQkJCSAqIE1lc3NhZ2UgZGVs +aXZlcmVkIHNvIHNlbnQgbmV3IG9uZSBhbmQgd2FpdCBmb3IgaXQKCQkJCSAqLwoJCQkJc2VuZF9t +c2coY3BnX2hhbmRsZSk7CgkJCX0KCQkJYnJlYWs7CgkJfQoJfSB3aGlsZSAoY29udCk7CgoJY3Nf +cmVwZWF0KGNzX3JlcyA9IGNwZ19sZWF2ZShjcGdfaGFuZGxlLCAmZ3JvdXBfbmFtZSkpOwoJYXNz +ZXJ0KGNzX3JlcyA9PSBDU19PSyk7CgoJY3NfcmVwZWF0KGNzX3JlcyA9IGNwZ19maW5hbGl6ZShj +cGdfaGFuZGxlKSk7Cglhc3NlcnQoY3NfcmVzID09IENTX09LKTsKCglMRUFWRSgpOwp9CgppbnQK +bWFpbih2b2lkKQp7CgoJRU5URVIoKTsKCglzZXRsaW5lYnVmKHN0ZG91dCk7CgoJdGVzdF9jcGco +KTsKCglMRUFWRSgpOwoKCXJldHVybiAoMCk7Cn0K" | base64 -d | tee "/tmp/corosync-api-test.c" +# - corosync-api-test.c +# corosync-api-test-mp.c +echo "LyoKICogQ29weXJpZ2h0IChjKSAyMDE5LCBSZWQgSGF0LCBJbmMuCiAqCiAqIFBlcm1pc3Npb24g +dG8gdXNlLCBjb3B5LCBtb2RpZnksIGFuZC9vciBkaXN0cmlidXRlIHRoaXMgc29mdHdhcmUgZm9y +IGFueQogKiBwdXJwb3NlIHdpdGggb3Igd2l0aG91dCBmZWUgaXMgaGVyZWJ5IGdyYW50ZWQsIHBy +b3ZpZGVkIHRoYXQgdGhlIGFib3ZlCiAqIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlz +c2lvbiBub3RpY2UgYXBwZWFyIGluIGFsbCBjb3BpZXMuCiAqCiAqIFRIRSBTT0ZUV0FSRSBJUyBQ +Uk9WSURFRCAiQVMgSVMiIEFORCBSRUQgSEFULCBJTkMuIERJU0NMQUlNUyBBTEwgV0FSUkFOVElF +UwogKiBXSVRIIFJFR0FSRCBUTyBUSElTIFNPRlRXQVJFIElOQ0xVRElORyBBTEwgSU1QTElFRCBX +QVJSQU5USUVTCiAqIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUy4gSU4gTk8gRVZFTlQg +U0hBTEwgUkVEIEhBVCwgSU5DLiBCRSBMSUFCTEUKICogRk9SIEFOWSBTUEVDSUFMLCBESVJFQ1Qs +IElORElSRUNULCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgT1IgQU5ZIERBTUFHRVMKICogV0hB +VFNPRVZFUiBSRVNVTFRJTkcgRlJPTSBMT1NTIE9GIFVTRSwgREFUQSBPUiBQUk9GSVRTLCBXSEVU +SEVSIElOIEFOIEFDVElPTgogKiBPRiBDT05UUkFDVCwgTkVHTElHRU5DRSBPUiBPVEhFUiBUT1JU +SU9VUyBBQ1RJT04sIEFSSVNJTkcgT1VUIE9GIE9SIElOCiAqIENPTk5FQ1RJT04gV0lUSCBUSEUg +VVNFIE9SIFBFUkZPUk1BTkNFIE9GIFRISVMgU09GVFdBUkUuCiAqCiAqIEF1dGhvcjogSmFuIEZy +aWVzc2UgPGpmcmllc3NlQHJlZGhhdC5jb20+CiAqLwoKLyoKICogTWFpbiBwcm9jZXNzIGNyZWF0 +ZXMgbXVsdGlwbGUgKE5PX0NISUxEUykgY2hpbGRzIGFuZCB3YWl0cyBmb3IgdGhlaXIgZXhpdC4K +ICogRWFjaCBjaGlsZCBqb2lucyBDUEcgZ3JvdXAgYW5kIHN0YXJ0cyBwcm9jZXNzaW5nIENQRyBl +dmVudHMuIEVhY2ggY2hpbGQgaXMKICogaWRlbnRpZmllZCBieSBJRCAobXlfaWQpIHdoaWNoIGlz +IHNldCBieSBtYWluIHByb2Nlc3MgaW4gaW5jcmVhc2luZyBvcmRlciAoc28KICogdmFsdWUgaXMg +MC4uTk9fQ0hJTERTLTEpLiBXaGVuIGFsbCBjaGlsZHMgam9pbiBDUEcgZ3JvdXAgKENvbmZjaGdD +YWxsYmFjayB2YXJpYWJsZQogKiBtZW1iZXJfbGlzdF9lbnRyaWVzIGlzIGVxdWFsIHRvIE5PX0NI +SUxEUykgdGhlbiBjaGlsZCB3aXRoIElEIDAgc2VuZHMgQ1BHIG1lc3NhZ2UKICogd2l0aCByYW5k +b20gbGVuZ3RoICh1cC10byBNQVhfTVNHX0xFTikgYW5kIHJhbmRvbSBjb250ZW50LiBXaGVuIGNo +aWxkIHdpdGggSUQgMQogKiByZWNlaXZlcyBtZXNzYWdlIGlzc3VlZCBieSBjaGlsZCB3aXRoIElE +IDAsIGl0IHNlbmRzIGFub3RoZXIgcmFuZG9tIG1lc3NhZ2UuCiAqIFRoaXMgcHJvY2VzcyBjb250 +aW51ZXMgd2l0aCBjaGlsZCB3aXRoIElEIDIsIHRoZW4gd2l0aCBjaGlsZCAzLCAuLi4gTk9fQ0hJ +TERTIC0gMSBhbmQKICogdGhlbiBvdmVybGFwcyBiYWNrIHRvIDAuIEVhY2ggY2hpbGQgY29tcGFy +ZXMgcmVjZWl2ZWQgbWVzc2FnZSBieSBnZW5lcmF0aW5nIHNhbWUKICogcmFuZG9tIG51bWJlcnMg +KHJhbmRfciBmdW5jdGlvbiBpcyB1c2VkKSBzdHJlYW0gYXMgc2VuZGVyIHNvIHNlbnRfcmFuZF9z +ZWVkIGFuZAogKiByZWNlaXZlZF9yYW5kX3NlZWQgbXVzdCBiZSBrZXB0IGluIHN5bmMuIEtlZXBp +bmcgcmVjZWllZF9yYW5kX3NlZWQgaW4gc3luYyBpcwogKiBzaW1wbGUsIGJlY2F1c2UgaXQgaXMg +dXBkYXRlZCBldmVyeSB0aW1lIHdoZW4gbWVzc2FnZSBpcyByZWNlaXZlZC4KICogc2VudF9yYW5k +X3NlZWQgaXMgdXBkYXRlZCBldGhlciBieSBzZW5kaW5nIG1lc3NhZ2Ugb3IgYnkKICogY2FsbGlu +ZyBhZGp1c3Rfc2VudF9yYW5kX3NlZWQgZnVuY3Rpb24uCiAqCiAqIFRoaXMgdGVzdCBjaGVja3Mg +Zm9sbG93aW5nIHByb3BlcnRpZXMgQ1BHOgogKiAtIE1vcmUgdGhhbiBvbmUgY2xpZW50IGNhbiBq +b2luIENQRyBncm91cAogKiAtIEVhY2ggY2xpZW50IGV2ZW50dWFsbHkgc2VlcyBhbGwgb3RoZXIg +Y2xpZW50cwogKiAtIEVhY2ggY2xpZW50IHJlY2VpdmVzIG1lc3NhZ2VzIHNlbnQgYnkgb3RoZXIg +Y2xpZW50cyBbMV0KICogLSBNZXNzYWdlIGlzIG5vdCBjb3JydXB0ZWQgWzFdCiAqIC0gTWVzc2Fn +ZXMgYXJlIGRlbGl2ZXJlZCB3aXRoIEZJRk8gcXVhcmFudGVlIFsxXQogKgogKiBbMV0gLSBFbnN1 +cmVkIGJ5IGVxdWFsaXR5IG9mIHJhbmRfciBnZW5lcmF0ZWQgYnl0ZXMgd2hlcmUgc2VuZGVyIHNl +ZWQKICogICAgICAgKHNlbnRfcmFuZF9zZWVkKSBhbmQgcmVjZWl2ZXIgc2VlZCAocmVjZWl2ZWRf +cmFuZF9zZWVkKSBhcmUga2VwdCBpbgogKiAgICAgICBzeW5jLgogKi8KCiNpbmNsdWRlIDxzeXMv +dHlwZXMuaD4KI2luY2x1ZGUgPHN5cy9zb2NrZXQuaD4KI2luY2x1ZGUgPHN5cy93YWl0Lmg+Cgoj +aW5jbHVkZSA8YXNzZXJ0Lmg+CiNpbmNsdWRlIDxlcnJuby5oPgojaW5jbHVkZSA8aW50dHlwZXMu +aD4KI2luY2x1ZGUgPHBvbGwuaD4KI2luY2x1ZGUgPHN0ZGlvLmg+CiNpbmNsdWRlIDxzdGRsaWIu +aD4KI2luY2x1ZGUgPHN0cmluZy5oPgojaW5jbHVkZSA8dW5pc3RkLmg+CgojaW5jbHVkZSA8Y29y +b3N5bmMvY29yb3R5cGVzLmg+CiNpbmNsdWRlIDxjb3Jvc3luYy9jcGcuaD4KCi8qCiAqIFByZWRl +ZmluZWQgdGVzdCBjb25zdGFudHMKICovCiNkZWZpbmUgVEVTVF9OT0RFSUQJCTEKI2RlZmluZSBU +RVNUX0dST1VQX05BTUUJCSJzbW9rZS1hcGktdGVzdC1jcGctZ3JvdXAtbXAiCiNkZWZpbmUgTUFY +X1JFVFJJRVMJCTMwCiNkZWZpbmUgTUFYX01TR19MRU4JCSgxMDI0ICogMTI4KQoKI2RlZmluZSBO +T19DSElMRFMJCTMKCiNkZWZpbmUgTUVTU0FHRVNfVE9fU0VOVAkoMTI4ICogTk9fQ0hJTERTKQoK +LyoKICogVXNlZnVsIG1hY3JvcwogKi8KI2RlZmluZSBjc19yZXBlYXQoY29kZSkgZG8gewkJCQlc +CglpbnQgY3NfcmVwZWF0X2NvdW50ZXIgPSAwOwkJCVwKCWRvIHsJCQkJCQlcCgkJaWYgKChjb2Rl +KSA9PSBDU19FUlJfVFJZX0FHQUlOKSB7CVwKCQkJY3NfcmVwZWF0X2NvdW50ZXIrKzsJCVwKCQkJ +cG9sbChOVUxMLCAwLCAxMDAwKTsJCVwKCQl9IGVsc2UgewkJCQlcCgkJCWJyZWFrOwkJCQlcCgkJ +fQkJCQkJXAoJfSB3aGlsZSAoY3NfcmVwZWF0X2NvdW50ZXIgPCBNQVhfUkVUUklFUyk7CVwKfSB3 +aGlsZSAoMCkKCiNpZm5kZWYgSU5GVElNCiNkZWZpbmUgSU5GVElNCQkJLTEKI2VuZGlmCgojZGVm +aW5lIEVOVEVSKCkgcHJpbnRmKCJbJWxkXSArICVzOiV1ICVzXG4iLCAobG9uZyBzaWduZWQgaW50 +KWdldHBpZCgpLCBfX0ZJTEVfXyxcCiAgICBfX0xJTkVfXywgX19mdW5jX18pCiNkZWZpbmUgTEVB +VkUoKSBwcmludGYoIlslbGRdIC0gJXM6JXUgJXNcbiIsIChsb25nIHNpZ25lZCBpbnQpZ2V0cGlk +KCksIF9fRklMRV9fLFwKICAgIF9fTElORV9fLCBfX2Z1bmNfXykKCnN0YXRpYyBpbnQzMl90IG15 +X2lkID0gLTE7CnN0YXRpYyBpbnQgZnVsbF9tZW1iZXJzaGlwX3NlZW4gPSAwOwpzdGF0aWMgaW50 +IHNlbnRfbWVzc2FnZXMgPSAwOwpzdGF0aWMgaW50IHRlc3RfY3BnX2xvb3BfY29udCA9IDE7Cgov +KgogKiBib3RoIHJhbmQgc2VlZHMgbXVzdCBiZSBpbiBzeW5jCiAqLwpzdGF0aWMgdW5zaWduZWQg +aW50IHNlbnRfcmFuZF9zZWVkID0gMDsKc3RhdGljIHVuc2lnbmVkIGludCByZWNlaXZlZF9yYW5k +X3NlZWQgPSAwOwpzdGF0aWMgaW50MzJfdCBleHBlY3RlZF9zZW5kZXJfaWQ7CnN0YXRpYyB1aW50 +MzJfdCBleHBlY3RlZF9tc2dfc2VxX25vID0gMDsKCnN0cnVjdCB0ZXN0X21zZyB7CglpbnQzMl90 +IHNlbmRlcl9pZCBfX2F0dHJpYnV0ZV9fICgoYWxpZ25lZCAoOCkpKTsKCXVpbnQzMl90IHNlcV9u +byBfX2F0dHJpYnV0ZV9fICgoYWxpZ25lZCAoOCkpKTsKCXVpbnQzMl90IGRhdGFfbGVuIF9fYXR0 +cmlidXRlX18gKChhbGlnbmVkICg4KSkpOwoJdW5zaWduZWQgY2hhciBkYXRhWzBdIF9fYXR0cmli +dXRlX18gKChhbGlnbmVkICg4KSkpOwp9OwoKc3RhdGljIHZvaWQKc2VuZF9tc2coY3BnX2hhbmRs +ZV90IGNwZ19oYW5kbGUpCnsKCXN0cnVjdCB0ZXN0X21zZyBtc2c7Cgl1bnNpZ25lZCBjaGFyICpk +YXRhOwoJdWludDMyX3QgdTMyOwoJc3RydWN0IGlvdmVjIGlvdlsyXTsKCWNzX2Vycm9yX3QgY3Nf +cmVzOwoKCUVOVEVSKCk7CgoJbXNnLnNlbmRlcl9pZCA9IG15X2lkOwoJbXNnLmRhdGFfbGVuID0g +cmFuZF9yKCZzZW50X3JhbmRfc2VlZCkgJSBNQVhfTVNHX0xFTjsKCW1zZy5zZXFfbm8gPSBleHBl +Y3RlZF9tc2dfc2VxX25vOwoKCWRhdGEgPSBtYWxsb2Moc2l6ZW9mKHVuc2lnbmVkIGNoYXIpICog +bXNnLmRhdGFfbGVuKTsKCWFzc2VydChkYXRhICE9IE5VTEwpOwoKCWZvciAodTMyID0gMDsgdTMy +IDwgbXNnLmRhdGFfbGVuOyB1MzIrKykgewoJCWRhdGFbdTMyXSA9ICh1bnNpZ25lZCBjaGFyKXJh +bmRfcigmc2VudF9yYW5kX3NlZWQpOwoJfQoKCWlvdlswXS5pb3ZfYmFzZSA9ICh2b2lkICopJm1z +ZzsKCWlvdlswXS5pb3ZfbGVuID0gc2l6ZW9mKG1zZyk7Cglpb3ZbMV0uaW92X2Jhc2UgPSAodm9p +ZCAqKWRhdGE7Cglpb3ZbMV0uaW92X2xlbiA9IG1zZy5kYXRhX2xlbjsKCgljc19yZXMgPSBjcGdf +bWNhc3Rfam9pbmVkKGNwZ19oYW5kbGUsIENQR19UWVBFX0FHUkVFRCwgaW92LCAyKTsKCWFzc2Vy +dChjc19yZXMgPT0gQ1NfT0spOwoKCWZyZWUoZGF0YSk7CgoJc2VudF9tZXNzYWdlcysrOwoKCUxF +QVZFKCk7Cn0KCnN0YXRpYyB2b2lkCmFkanVzdF9zZW50X3JhbmRfc2VlZCh2b2lkKQp7Cgl1aW50 +MzJfdCBkYXRhX2xlbjsKCXVpbnQzMl90IHUzMjsKCglkYXRhX2xlbiA9IHJhbmRfcigmc2VudF9y +YW5kX3NlZWQpICUgTUFYX01TR19MRU47CgoJZm9yICh1MzIgPSAwOyB1MzIgPCBkYXRhX2xlbjsg +dTMyKyspIHsKCQkodm9pZClyYW5kX3IoJnNlbnRfcmFuZF9zZWVkKTsKCX0KfQoKc3RhdGljIHZv +aWQKRGVsaXZlckNhbGxiYWNrKGNwZ19oYW5kbGVfdCBoYW5kbGUsCiAgICBjb25zdCBzdHJ1Y3Qg +Y3BnX25hbWUgKmdyb3VwTmFtZSwKICAgIHVpbnQzMl90IG5vZGVpZCwKICAgIHVpbnQzMl90IHBp +ZCwKICAgIHZvaWQgKmNwZ19tc2csCiAgICBzaXplX3QgY3BnX21zZ19sZW4pCnsKCXN0cnVjdCB0 +ZXN0X21zZyAqbXNnOwoJdWludDMyX3QgdTMyOwoKCUVOVEVSKCk7CgoJYXNzZXJ0KG5vZGVpZCA9 +PSBURVNUX05PREVJRCk7CgoJYXNzZXJ0KGNwZ19tc2dfbGVuID49IHNpemVvZihzdHJ1Y3QgdGVz +dF9tc2cpKTsKCgltc2cgPSAoc3RydWN0IHRlc3RfbXNnICopY3BnX21zZzsKCWFzc2VydChtc2ct +PnNlbmRlcl9pZCA9PSBleHBlY3RlZF9zZW5kZXJfaWQpOwoKCWV4cGVjdGVkX3NlbmRlcl9pZCA9 +IChleHBlY3RlZF9zZW5kZXJfaWQgKyAxKSAlIE5PX0NISUxEUzsKCglhc3NlcnQobXNnLT5zZXFf +bm8gPT0gZXhwZWN0ZWRfbXNnX3NlcV9ubyk7CglleHBlY3RlZF9tc2dfc2VxX25vKys7CgoJYXNz +ZXJ0KGNwZ19tc2dfbGVuID09IG1zZy0+ZGF0YV9sZW4gKyBzaXplb2Yoc3RydWN0IHRlc3RfbXNn +KSk7CgoJLyoKCSAqIE1lc3NhZ2UgaGFzIGV4cGVjdGVkIGxlbmd0aCBhbmQgY29udGVudAoJICov +Cglhc3NlcnQobXNnLT5kYXRhX2xlbiA9PSAodWludDMyX3QpKHJhbmRfcigmcmVjZWl2ZWRfcmFu +ZF9zZWVkKSAlIE1BWF9NU0dfTEVOKSk7CgoJZm9yICh1MzIgPSAwOyB1MzIgPCBtc2ctPmRhdGFf +bGVuOyB1MzIrKykgewoJCWFzc2VydChtc2ctPmRhdGFbdTMyXSA9PSAodW5zaWduZWQgY2hhcily +YW5kX3IoJnJlY2VpdmVkX3JhbmRfc2VlZCkpOwoJfQoKCWlmIChleHBlY3RlZF9tc2dfc2VxX25v +ID4gTUVTU0FHRVNfVE9fU0VOVCkgewoJCXRlc3RfY3BnX2xvb3BfY29udCA9IDA7Cgl9CgoJaWYg +KGV4cGVjdGVkX3NlbmRlcl9pZCA9PSBteV9pZCkgewoJCXNlbmRfbXNnKGhhbmRsZSk7Cgl9IGVs +c2UgewoJCWFkanVzdF9zZW50X3JhbmRfc2VlZCgpOwoJfQoKCUxFQVZFKCk7Cn0KCnN0YXRpYyB2 +b2lkClRvdGVtQ29uZmNoZ0NhbGxiYWNrKGNwZ19oYW5kbGVfdCBoYW5kbGUsCiAgICBzdHJ1Y3Qg +Y3BnX3JpbmdfaWQgcmluZ19pZCwKICAgIHVpbnQzMl90IG1lbWJlcl9saXN0X2VudHJpZXMsCiAg +ICBjb25zdCB1aW50MzJfdCAqbWVtYmVyX2xpc3QpCnsKCglFTlRFUigpOwoKCWFzc2VydChtZW1i +ZXJfbGlzdF9lbnRyaWVzID09IDEpOwoJYXNzZXJ0KG1lbWJlcl9saXN0WzBdID09IFRFU1RfTk9E +RUlEKTsKCglMRUFWRSgpOwp9CgpzdGF0aWMgdm9pZApDb25mY2hnQ2FsbGJhY2soY3BnX2hhbmRs +ZV90IGhhbmRsZSwKICAgIGNvbnN0IHN0cnVjdCBjcGdfbmFtZSAqZ3JvdXBfbmFtZSwKICAgIGNv +bnN0IHN0cnVjdCBjcGdfYWRkcmVzcyAqbWVtYmVyX2xpc3QsIHNpemVfdCBtZW1iZXJfbGlzdF9l +bnRyaWVzLAogICAgY29uc3Qgc3RydWN0IGNwZ19hZGRyZXNzICpsZWZ0X2xpc3QsIHNpemVfdCBs +ZWZ0X2xpc3RfZW50cmllcywKICAgIGNvbnN0IHN0cnVjdCBjcGdfYWRkcmVzcyAqam9pbmVkX2xp +c3QsIHNpemVfdCBqb2luZWRfbGlzdF9lbnRyaWVzKQp7CglpbnQgaTsKCglFTlRFUigpOwoKCWFz +c2VydChncm91cF9uYW1lLT5sZW5ndGggPT0gc3RybGVuKFRFU1RfR1JPVVBfTkFNRSkpOwoJYXNz +ZXJ0KG1lbWNtcChncm91cF9uYW1lLT52YWx1ZSwgVEVTVF9HUk9VUF9OQU1FLCBzdHJsZW4oVEVT +VF9HUk9VUF9OQU1FKSkgPT0gMCk7CgoJZm9yIChpID0gMDsgaSA8IG1lbWJlcl9saXN0X2VudHJp +ZXM7IGkrKykgewoJCWFzc2VydChtZW1iZXJfbGlzdFtpXS5ub2RlaWQgPT0gVEVTVF9OT0RFSUQp +OwoJfQoKCWlmICghZnVsbF9tZW1iZXJzaGlwX3NlZW4gJiYgbWVtYmVyX2xpc3RfZW50cmllcyA9 +PSBOT19DSElMRFMpIHsKCQlpZiAobXlfaWQgPT0gMCkgewoJCQkvKgoJCQkgKiBGaXJzdCBjaGls +ZCBzZW5kcyBmaXJzdCBtZXNzYWdlCgkJCSAqLwoJCQlzZW5kX21zZyhoYW5kbGUpOwoJCX0gZWxz +ZSB7CgkJCWFkanVzdF9zZW50X3JhbmRfc2VlZCgpOwoJCX0KCgkJZnVsbF9tZW1iZXJzaGlwX3Nl +ZW4gPSAxOwoJfQoKCUxFQVZFKCk7Cn0KCnN0YXRpYyBjcGdfbW9kZWxfdjFfZGF0YV90IG1vZGVs +X2RhdGEgPSB7CgkuY3BnX2RlbGl2ZXJfZm4gPQlEZWxpdmVyQ2FsbGJhY2ssCgkuY3BnX2NvbmZj +aGdfZm4gPQlDb25mY2hnQ2FsbGJhY2ssCgkuY3BnX3RvdGVtX2NvbmZjaGdfZm4gPQlUb3RlbUNv +bmZjaGdDYWxsYmFjaywKCS5mbGFncyA9CQlDUEdfTU9ERUxfVjFfREVMSVZFUl9JTklUSUFMX1RP +VEVNX0NPTkYsCn07CgoKc3RhdGljIHZvaWQKdGVzdF9jcGcodm9pZCkKewoJY3BnX2hhbmRsZV90 +IGNwZ19oYW5kbGU7CglzdHJ1Y3QgY3BnX25hbWUgZ3JvdXBfbmFtZTsKCWNzX2Vycm9yX3QgY3Nf +cmVzOwoJdW5zaWduZWQgaW50IGxvY2FsX25vZGVpZDsKCWludCBjcGdfZmQ7CglzdHJ1Y3QgcG9s +bGZkIHBmZDsKCWludCBwb2xsX3JlczsKCglFTlRFUigpOwoKCXN0cmNweShncm91cF9uYW1lLnZh +bHVlLCBURVNUX0dST1VQX05BTUUpOwoJZ3JvdXBfbmFtZS5sZW5ndGggPSBzdHJsZW4oVEVTVF9H +Uk9VUF9OQU1FKTsKCgljc19yZXBlYXQoY3NfcmVzID0gY3BnX21vZGVsX2luaXRpYWxpemUoJmNw +Z19oYW5kbGUsIENQR19NT0RFTF9WMSwKCSAgICAoY3BnX21vZGVsX2RhdGFfdCAqKSZtb2RlbF9k +YXRhLCBOVUxMKSk7Cglhc3NlcnQoY3NfcmVzID09IENTX09LKTsKCgljc19yZXBlYXQoY3NfcmVz +ID0gY3BnX2pvaW4oY3BnX2hhbmRsZSwgJmdyb3VwX25hbWUpKTsKCWFzc2VydChjc19yZXMgPT0g +Q1NfT0spOwoKCWNzX3JlcGVhdChjc19yZXMgPSBjcGdfbG9jYWxfZ2V0KGNwZ19oYW5kbGUsICZs +b2NhbF9ub2RlaWQpKTsKCWFzc2VydChjc19yZXMgPT0gQ1NfT0spOwoJYXNzZXJ0KGxvY2FsX25v +ZGVpZCA9PSBURVNUX05PREVJRCk7CgoJY3NfcmVwZWF0KGNzX3JlcyA9IGNwZ19mZF9nZXQoY3Bn +X2hhbmRsZSwgJmNwZ19mZCkpOwoJYXNzZXJ0KGNzX3JlcyA9PSBDU19PSyk7CgoJZG8gewoJCXBm +ZC5mZCA9IGNwZ19mZDsKCQlwZmQuZXZlbnRzID0gUE9MTElOOwoJCXBmZC5yZXZlbnRzID0gMDsK +CgkJcG9sbF9yZXMgPSBwb2xsKCZwZmQsIDEsIElORlRJTSk7CgkJaWYgKHBvbGxfcmVzID09IC0x +KSB7CgkJCXBlcnJvcigicG9sbF9yZXMgPT0gLTEiKTsKCQl9CgoJCWFzc2VydChwb2xsX3JlcyAh +PSAwKTsKCQlhc3NlcnQocGZkLnJldmVudHMgJiBQT0xMSU4pOwoKCQljc19yZXBlYXQoY3NfcmVz +ID0gY3BnX2Rpc3BhdGNoKGNwZ19oYW5kbGUsIENTX0RJU1BBVENIX0FMTCkpOwoJCWFzc2VydChj +c19yZXMgPT0gQ1NfT0spOwoJfSB3aGlsZSAodGVzdF9jcGdfbG9vcF9jb250KTsKCgljc19yZXBl +YXQoY3NfcmVzID0gY3BnX2xlYXZlKGNwZ19oYW5kbGUsICZncm91cF9uYW1lKSk7Cglhc3NlcnQo +Y3NfcmVzID09IENTX09LKTsKCgljc19yZXBlYXQoY3NfcmVzID0gY3BnX2ZpbmFsaXplKGNwZ19o +YW5kbGUpKTsKCWFzc2VydChjc19yZXMgPT0gQ1NfT0spOwoKCUxFQVZFKCk7Cn0KCmludAptYWlu +KHZvaWQpCnsKCWludCBpOwoJcGlkX3QgZm9ya19yZXM7CglwaWRfdCB3YWl0X3JlczsKCWludCBz +dGF0dXM7CgoJRU5URVIoKTsKCglzZXRsaW5lYnVmKHN0ZG91dCk7CgoJZm9yIChpID0gMDsgaSA8 +IE5PX0NISUxEUzsgaSsrKSB7CgkJbXlfaWQgPSBpOwoKCQlmb3JrX3JlcyA9IGZvcmsoKTsKCgkJ +aWYgKGZvcmtfcmVzID09IC0xKSB7CgkJCXBlcnJvcigiZm9yayIpOwoJCX0KCgkJaWYgKGZvcmtf +cmVzID09IDApIHsKCQkJLyoKCQkJICogQ2hpbGQKCQkJICovCgkJCWJyZWFrIDsKCQl9IGVsc2Ug +ewoJCQkvKgoJCQkgKiBQYXJlbnQKCQkJICovCgkJCW15X2lkID0gLTE7CgkJfQoJfQoKCWlmIChm +b3JrX3JlcyA9PSAwKSB7CgkJLyoKCQkgKiBDaGlsZCBydW5zIHRoZSB0ZXN0CgkJICovCgkJdGVz +dF9jcGcoKTsKCX0gZWxzZSB7CgkJLyoKCQkgKiBXYWl0IGZvciBjaGlsZHMKCQkgKi8KCQlmb3Ig +KGkgPSAwOyBpIDwgTk9fQ0hJTERTOyBpKyspIHsKCQkJd2FpdF9yZXMgPSB3YWl0KCZzdGF0dXMp +OwoJCQlpZiAod2FpdF9yZXMgPT0gLTEpIHsKCQkJCXBlcnJvcigid2FpdCIpOwoJCQl9CgoJCQlh +c3NlcnQoV0lGRVhJVEVEKHN0YXR1cykpOwoJCQlhc3NlcnQoV0VYSVRTVEFUVVMoc3RhdHVzKSA9 +PSAwKTsKCQl9Cgl9CgoJTEVBVkUoKTsKCglyZXR1cm4gKDApOwp9Cg==" | base64 -d | tee "/tmp/corosync-api-test-mp.c" +# - corosync-api-test-mp.c +################## +# Test functions # +################## +test_corosync_v() { + # Check corosync -v exits without error and + # result version contain numbers in path format [0-9]*.[0-9]*.[0-9] + ver_res=$(corosync -v) + [ "$ver_res" != "${ver_res/[0-9]*\.[0-9]*\.[0-9]/}" ] +} + +test_corosync_keygen() { + rm -f "$COROSYNC_AUTHKEY" + corosync-keygen + + # File exists + [ -f "$COROSYNC_AUTHKEY" ] + + # ... and is not empty (wc format is "SIZE FILENAME" - remove FILENAME part) + wc_res=$(wc -c "$COROSYNC_AUTHKEY") + [ "${wc_res%% *}" -gt 0 ] +} + +# test_corosync_start crypto +# crypto can be on or off +test_corosync_start() { + generate_corosync_conf "$1" > "$COROSYNC_CONF" + cat "$COROSYNC_CONF" + + service_start "corosync" +} + +test_corosync_stop() { + service_stop "corosync" +} + +test_corosync_quorumtool() { + quorumtool_res_file=`mktemp` + # This is already fixed in upstream db38e3958c4f88d5d06e8f7c83d6d90334d9fbd2 + (corosync-quorumtool -ips || true) | tee "$quorumtool_res_file" + + # Ensure this is single node cluster + grep -qi '^Nodes:.*1$' "$quorumtool_res_file" + # Current node id is 1 + grep -qi '^Node ID:.*1$' "$quorumtool_res_file" + # Is quorate (libquorum) + grep -qi '^Quorate:.*Yes$' "$quorumtool_res_file" + # Quorum is 1 + grep -qi '^Quorum:.*1' "$quorumtool_res_file" + # Is quorate (libvotequorum) + grep -qi '^Flags:.*Quorate' "$quorumtool_res_file" + + rm -f "$quorumtool_res_file" +} + +test_corosync_cmapctl() { + cmapctl_res_file=`mktemp` + corosync-cmapctl | tee "$cmapctl_res_file" + # cluster_name key exists in full output + grep -qi '^totem.cluster_name (str) = smoketestcluster$' "$cmapctl_res_file" + + corosync-cmapctl "totem." | tee "$cmapctl_res_file" + # cluster_name key exists in reduced output + grep -qi '^totem.cluster_name (str) = smoketestcluster$' "$cmapctl_res_file" + + # cluster_name key should be returned + corosync-cmapctl -g "totem.cluster_name" | tee "$cmapctl_res_file" + grep -qi '^totem.cluster_name (str) = smoketestcluster$' "$cmapctl_res_file" + + rm -f "$cmapctl_res_file" +} + +# test_corosync_reload - requires stopped corosync +test_corosync_reload() { + cmapctl_res_file=`mktemp` + + test_corosync_start "off" + + # Get current token timeout + corosync-cmapctl -g "runtime.config.totem.token" | tee "$cmapctl_res_file" + cmapctl_res=$(cat "$cmapctl_res_file") + # Format is runtime.config.totem.token (u32) = value + token_pre_reload=${cmapctl_res##* } + [ "$token_pre_reload" -eq "$TOKEN_TIMEOUT" ] + + # Generate new corosync.conf with token_timeout*10 + new_token_timeout=$((TOKEN_TIMEOUT*10)) + generate_corosync_conf "off" "$new_token_timeout" > "$COROSYNC_CONF" + cat "$COROSYNC_CONF" + + # Main call of the test + corosync-cfgtool -R + + # Check that new token timeout is in use + corosync-cmapctl -g "runtime.config.totem.token" | tee "$cmapctl_res_file" + cmapctl_res=$(cat "$cmapctl_res_file") + # Format is runtime.config.totem.token (u32) = value + token_post_reload=${cmapctl_res##* } + [ "$token_post_reload" -eq "$new_token_timeout" ] + + test_corosync_stop + + rm -f "$cmapctl_res_file" +} + +test_corosync_api() { + cflags=$(pkg-config --cflags libcpg) + libs=$(pkg-config --libs libcpg) + + gcc -ggdb -Wall $cflags "/tmp/corosync-api-test.c" \ + $libs -o "/tmp/corosync-api-test" + + /tmp/corosync-api-test +} + +test_corosync_api_mp() { + cflags=$(pkg-config --cflags libcpg) + libs=$(pkg-config --libs libcpg) + + gcc -ggdb -Wall $cflags "/tmp/corosync-api-test-mp.c" \ + $libs -o "/tmp/corosync-api-test-mp" + + /tmp/corosync-api-test-mp +} + +test_corosync_man_pages() { + # At least these man pages should be installed + expected_mp="corosync corosync.conf corosync-cfgtool corosync-cmapctl + corosync-keygen corosync-quorumtool" + + for mp in $expected_mp;do + man -w "$mp" + done +} + +######## +# main # +######## +if [ -z "$PREFIX" ];then + echo "PREFIX not defined. Do not run *.inc.sh directly" + exit 1 +fi + +test_corosync_v +test_corosync_keygen +test_corosync_man_pages + +for crypto in "off" "on";do + test_corosync_start "$crypto" + test_corosync_quorumtool + test_corosync_cmapctl + test_corosync_api + test_corosync_api_mp + test_corosync_stop +done + +test_corosync_reload diff --git a/tests/tests.yml b/tests/tests.yml new file mode 100644 index 0000000..39b6209 --- /dev/null +++ b/tests/tests.yml @@ -0,0 +1,12 @@ +- hosts: localhost + roles: + - role: standard-test-basic + tags: + - classic + tests: + - smoke + required_packages: + - gcc + - iproute + - corosync + - corosync-devel