Log: /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/logs/users-8-0.log
WARNING: version difference between client (1.29) and server (1.25) exceeds the supported minor version skew of +/-1
WARNING: version difference between client (1.29) and server (1.25) exceeds the supported minor version skew of +/-1
+ create_infra users-3908
+ local ns=users-3908
+ '[' -n pxc-operator ']'
+ grep -v NAMESPACE
+ kubectl get pxc --all-namespaces -o wide
+ xargs -L 1 sh -xc 'kubectl patch pxc -n $0 $1 --type=merge -p "{\"metadata\":{\"finalizers\":[]}}"'
+ kubectl patch pxc -n users-29066 some-name --type=merge -p '{"metadata":{"finalizers":[]}}'
perconaxtradbcluster.pxc.percona.com/some-name patched
+ kubectl_bin delete pxc --all --all-namespaces
++ mktemp
+ local LAST_OUT=/tmp/tmp.fvv0hhisAn
++ mktemp
+ local LAST_ERR=/tmp/tmp.f7puLm32y6
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl delete pxc --all --all-namespaces
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.fvv0hhisAn
perconaxtradbcluster.pxc.percona.com "some-name" deleted
+ cat /tmp/tmp.f7puLm32y6
+ rm /tmp/tmp.fvv0hhisAn /tmp/tmp.f7puLm32y6
+ return 0
+ kubectl_bin delete pxc-backup --all --all-namespaces
++ mktemp
+ local LAST_OUT=/tmp/tmp.zt0lDeFiDX
++ mktemp
+ local LAST_ERR=/tmp/tmp.jqJgA5aZOC
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl delete pxc-backup --all --all-namespaces
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.zt0lDeFiDX
No resources found
+ cat /tmp/tmp.jqJgA5aZOC
+ rm /tmp/tmp.zt0lDeFiDX /tmp/tmp.jqJgA5aZOC
+ return 0
+ kubectl_bin delete pxc-restore --all --all-namespaces
++ mktemp
+ local LAST_OUT=/tmp/tmp.wrAcVXCcZ4
++ mktemp
+ local LAST_ERR=/tmp/tmp.80eB9jCepY
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl delete pxc-restore --all --all-namespaces
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.wrAcVXCcZ4
No resources found
+ cat /tmp/tmp.80eB9jCepY
+ rm /tmp/tmp.wrAcVXCcZ4 /tmp/tmp.80eB9jCepY
+ return 0
+ create_namespace pxc-operator
+ local namespace=pxc-operator
+ local skip_clean_namespace=
+ [[ 1 == 1 ]]
+ [[ -z '' ]]
+ destroy_chaos_mesh
++ tail -n1
++ awk '-F ' '{print $2}'
++ helm list --all-namespaces --filter chaos-mesh
++ sed s/NAMESPACE//
+ local chaos_mesh_ns=
+ desc 'destroy chaos-mesh'
+ set +o xtrace


-----------------------------------------------------------------------------------
destroy chaos-mesh
-----------------------------------------------------------------------------------

++ grep chaos-mesh
++ awk '{print $1}'
++ kubectl api-resources
+ '[' -n '' ']'
++ kubectl get crd
++ grep chaos-mesh.org
++ awk '{print $1}'
+ timeout 30 kubectl delete crd
error: resource(s) were provided, but no name was specified
+ :
++ kubectl get clusterrolebinding
++ awk '{print $1}'
++ grep chaos-mesh
+ timeout 30 kubectl delete clusterrolebinding
error: resource(s) were provided, but no name was specified
+ :
++ grep chaos-mesh
++ awk '{print $1}'
++ kubectl get clusterrole
+ timeout 30 kubectl delete clusterrole
error: resource(s) were provided, but no name was specified
+ :
++ kubectl get MutatingWebhookConfiguration
++ awk '{print $1}'
++ grep chaos-mesh
+ timeout 30 kubectl delete MutatingWebhookConfiguration
error: resource(s) were provided, but no name was specified
+ :
++ kubectl get ValidatingWebhookConfiguration
++ grep chaos-mesh
++ awk '{print $1}'
+ timeout 30 kubectl delete ValidatingWebhookConfiguration
error: resource(s) were provided, but no name was specified
+ :
++ awk '{print $1}'
++ grep validate-auth
++ kubectl get ValidatingWebhookConfiguration
+ timeout 30 kubectl delete ValidatingWebhookConfiguration
error: resource(s) were provided, but no name was specified
+ :
+ desc 'cleaned up all old namespaces'
+ set +o xtrace


-----------------------------------------------------------------------------------
cleaned up all old namespaces
-----------------------------------------------------------------------------------

+ egrep -v '^kube-|^default$|Terminating|pxc-operator|openshift|^NAME'
+ '[' -n '' ']'
+ desc 'cleaned up old namespaces pxc-operator'
+ set +o xtrace


-----------------------------------------------------------------------------------
cleaned up old namespaces pxc-operator
-----------------------------------------------------------------------------------

+ kubectl_bin delete namespace pxc-operator
++ mktemp
+ local LAST_OUT=/tmp/tmp.79IAUPfmuX
++ mktemp
+ kubectl_bin get ns
+ awk '{print$1}'
+ xargs kubectl delete ns
+ local LAST_ERR=/tmp/tmp.VzmHfLGZXq
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl delete namespace pxc-operator
++ mktemp
+ local LAST_OUT=/tmp/tmp.2KaJnXlHvn
++ mktemp
+ local LAST_ERR=/tmp/tmp.qtEqDYfyvj
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl get ns
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.2KaJnXlHvn
+ cat /tmp/tmp.qtEqDYfyvj
+ rm /tmp/tmp.2KaJnXlHvn /tmp/tmp.qtEqDYfyvj
+ return 0
namespace "users-29066" deleted
Error from server (Forbidden): namespaces "default" is forbidden: this namespace may not be deleted
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.79IAUPfmuX
namespace "pxc-operator" deleted
+ cat /tmp/tmp.VzmHfLGZXq
+ rm /tmp/tmp.79IAUPfmuX /tmp/tmp.VzmHfLGZXq
+ return 0
+ wait_for_delete namespace/pxc-operator
+ local res=namespace/pxc-operator
+ echo -n 'namespace/pxc-operator - '
namespace/pxc-operator - + set +o xtrace
Error from server (NotFound): namespaces "pxc-operator" not found
+ desc 'create namespace pxc-operator'
+ set +o xtrace


-----------------------------------------------------------------------------------
create namespace pxc-operator
-----------------------------------------------------------------------------------

+ kubectl_bin create namespace pxc-operator
++ mktemp
+ local LAST_OUT=/tmp/tmp.YA8xhOELDB
++ mktemp
+ local LAST_ERR=/tmp/tmp.wqdoO26LLI
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl create namespace pxc-operator
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.YA8xhOELDB
namespace/pxc-operator created
+ cat /tmp/tmp.wqdoO26LLI
+ rm /tmp/tmp.YA8xhOELDB /tmp/tmp.wqdoO26LLI
+ return 0
++ kubectl_bin config current-context
+++ mktemp
++ local LAST_OUT=/tmp/tmp.ADUj1J9TEO
+++ mktemp
++ local LAST_ERR=/tmp/tmp.paIlzP1JJ5
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl config current-context
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.ADUj1J9TEO
++ cat /tmp/tmp.paIlzP1JJ5
++ rm /tmp/tmp.ADUj1J9TEO /tmp/tmp.paIlzP1JJ5
++ return 0
+ kubectl_bin config set-context gke_cloud-dev-112233_us-central1-a_jen-pxc-1522-1ed4605b-21-cluster3 --namespace=pxc-operator
++ mktemp
+ local LAST_OUT=/tmp/tmp.dMDSeekKUt
++ mktemp
+ local LAST_ERR=/tmp/tmp.IgWREkuR2B
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl config set-context gke_cloud-dev-112233_us-central1-a_jen-pxc-1522-1ed4605b-21-cluster3 --namespace=pxc-operator
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.dMDSeekKUt
Context "gke_cloud-dev-112233_us-central1-a_jen-pxc-1522-1ed4605b-21-cluster3" modified.
+ cat /tmp/tmp.IgWREkuR2B
+ rm /tmp/tmp.dMDSeekKUt /tmp/tmp.IgWREkuR2B
+ return 0
+ deploy_operator
+ desc 'start PXC operator'
+ set +o xtrace


-----------------------------------------------------------------------------------
start PXC operator
-----------------------------------------------------------------------------------

+ kubectl_bin apply --server-side --force-conflicts -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/deploy/crd.yaml
++ mktemp
+ local LAST_OUT=/tmp/tmp.2xkjxW0a30
++ mktemp
+ local LAST_ERR=/tmp/tmp.ysnzyra3hk
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl apply --server-side --force-conflicts -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/deploy/crd.yaml
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.2xkjxW0a30
customresourcedefinition.apiextensions.k8s.io/perconaxtradbclusterbackups.pxc.percona.com serverside-applied
customresourcedefinition.apiextensions.k8s.io/perconaxtradbclusterrestores.pxc.percona.com serverside-applied
customresourcedefinition.apiextensions.k8s.io/perconaxtradbclusters.pxc.percona.com serverside-applied
+ cat /tmp/tmp.ysnzyra3hk
+ rm /tmp/tmp.2xkjxW0a30 /tmp/tmp.ysnzyra3hk
+ return 0
+ '[' -n pxc-operator ']'
+ apply_rbac cw-rbac
+ local operator_namespace=pxc-operator
+ local rbac=cw-rbac
+ cat /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/deploy/cw-rbac.yaml
+ sed -e 's^namespace: .*^namespace: pxc-operator^'
+ kubectl_bin apply -f -
++ mktemp
+ local LAST_OUT=/tmp/tmp.0GeC9Ek9wI
++ mktemp
+ local LAST_ERR=/tmp/tmp.KfG2UcUI4M
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl apply -f -
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.0GeC9Ek9wI
clusterrole.rbac.authorization.k8s.io/percona-xtradb-cluster-operator unchanged
serviceaccount/percona-xtradb-cluster-operator created
clusterrolebinding.rbac.authorization.k8s.io/service-account-percona-xtradb-cluster-operator unchanged
+ cat /tmp/tmp.KfG2UcUI4M
+ rm /tmp/tmp.0GeC9Ek9wI /tmp/tmp.KfG2UcUI4M
+ return 0
+ cat /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/deploy/cw-operator.yaml
+ sed -e 's^image: .*^image: perconalab/percona-xtradb-cluster-operator:PR-1522-1ed4605b^'
+ sed -e 's^failureThreshold: .*^failureThreshold: 10^'
+ yq eval '(select(.kind == "Deployment").spec.template.spec.containers[] | select(.name == "percona-xtradb-cluster-operator").env[] | select(.name == "LOG_LEVEL").value) = "DEBUG"' -
+ kubectl_bin apply -f -
+ yq eval '(select(.kind == "Deployment").spec.template.spec.containers[] | select(.name == "percona-xtradb-cluster-operator").env[] | select(.name == "DISABLE_TELEMETRY").value) = "true"' -
++ mktemp
+ local LAST_OUT=/tmp/tmp.iaQ7JcBDd9
++ mktemp
+ local LAST_ERR=/tmp/tmp.4GlNMCJU7g
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl apply -f -
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.iaQ7JcBDd9
deployment.apps/percona-xtradb-cluster-operator created
service/percona-xtradb-cluster-operator created
+ cat /tmp/tmp.4GlNMCJU7g
+ rm /tmp/tmp.iaQ7JcBDd9 /tmp/tmp.4GlNMCJU7g
+ return 0
+ sleep 10
+ kubectl_bin wait --for=condition=Ready pods -l app.kubernetes.io/component=operator,app.kubernetes.io/instance=percona-xtradb-cluster-operator,app.kubernetes.io/name=percona-xtradb-cluster-operator --timeout=30s
++ mktemp
+ local LAST_OUT=/tmp/tmp.QmYdLKBLWP
++ mktemp
+ local LAST_ERR=/tmp/tmp.v5kOvyCNTk
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl wait --for=condition=Ready pods -l app.kubernetes.io/component=operator,app.kubernetes.io/instance=percona-xtradb-cluster-operator,app.kubernetes.io/name=percona-xtradb-cluster-operator --timeout=30s
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.QmYdLKBLWP
pod/percona-xtradb-cluster-operator-6dbd475d79-2qqt5 condition met
+ cat /tmp/tmp.v5kOvyCNTk
+ rm /tmp/tmp.QmYdLKBLWP /tmp/tmp.v5kOvyCNTk
+ return 0
++ get_operator_pod
++ local label_prefix=app.kubernetes.io/
+++ kubectl get pods --selector=app.kubernetes.io/name=percona-xtradb-cluster-operator -n pxc-operator
+++ grep -c percona-xtradb-cluster-operator
++ local check_label=1
++ [[ 1 -eq 0 ]]
++ kubectl_bin get pods --selector=app.kubernetes.io/name=percona-xtradb-cluster-operator -o 'jsonpath={.items[].metadata.name}' -n pxc-operator
+++ mktemp
++ local LAST_OUT=/tmp/tmp.f2nTNsw1OH
+++ mktemp
++ local LAST_ERR=/tmp/tmp.3esMGh32lZ
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=app.kubernetes.io/name=percona-xtradb-cluster-operator -o 'jsonpath={.items[].metadata.name}' -n pxc-operator
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.f2nTNsw1OH
++ cat /tmp/tmp.3esMGh32lZ
++ rm /tmp/tmp.f2nTNsw1OH /tmp/tmp.3esMGh32lZ
++ return 0
+ wait_pod percona-xtradb-cluster-operator-6dbd475d79-2qqt5 480 pxc-operator
+ local pod=percona-xtradb-cluster-operator-6dbd475d79-2qqt5
+ local max_retry=480
+ local ns=pxc-operator
++ echo percona-xtradb-cluster-operator-6dbd475d79-2qqt5
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/percona-xtradb-cluster-operator-6dbd475d79-2qqt5 condition met
percona-xtradb-cluster-operator-6dbd475d79-2qqt5.Ok
+ sleep 3
+ create_namespace users-3908
+ local namespace=users-3908
+ local skip_clean_namespace=
+ [[ 1 == 1 ]]
+ [[ -z '' ]]
+ destroy_chaos_mesh
++ awk '-F ' '{print $2}'
++ tail -n1
++ helm list --all-namespaces --filter chaos-mesh
++ sed s/NAMESPACE//
+ local chaos_mesh_ns=
+ desc 'destroy chaos-mesh'
+ set +o xtrace


-----------------------------------------------------------------------------------
destroy chaos-mesh
-----------------------------------------------------------------------------------

++ grep chaos-mesh
++ awk '{print $1}'
++ kubectl api-resources
+ '[' -n '' ']'
++ kubectl get crd
++ grep chaos-mesh.org
++ awk '{print $1}'
+ timeout 30 kubectl delete crd
error: resource(s) were provided, but no name was specified
+ :
++ kubectl get clusterrolebinding
++ grep chaos-mesh
++ awk '{print $1}'
+ timeout 30 kubectl delete clusterrolebinding
error: resource(s) were provided, but no name was specified
+ :
++ kubectl get clusterrole
++ grep chaos-mesh
++ awk '{print $1}'
+ timeout 30 kubectl delete clusterrole
error: resource(s) were provided, but no name was specified
+ :
++ kubectl get MutatingWebhookConfiguration
++ grep chaos-mesh
++ awk '{print $1}'
+ timeout 30 kubectl delete MutatingWebhookConfiguration
error: resource(s) were provided, but no name was specified
+ :
++ kubectl get ValidatingWebhookConfiguration
++ grep chaos-mesh
++ awk '{print $1}'
+ timeout 30 kubectl delete ValidatingWebhookConfiguration
error: resource(s) were provided, but no name was specified
+ :
++ kubectl get ValidatingWebhookConfiguration
++ grep validate-auth
++ awk '{print $1}'
+ timeout 30 kubectl delete ValidatingWebhookConfiguration
error: resource(s) were provided, but no name was specified
+ :
+ desc 'cleaned up all old namespaces'
+ set +o xtrace


-----------------------------------------------------------------------------------
cleaned up all old namespaces
-----------------------------------------------------------------------------------

+ kubectl_bin get ns
+ egrep -v '^kube-|^default$|Terminating|pxc-operator|openshift|^NAME'
+ awk '{print$1}'
+ '[' -n '' ']'
+ desc 'cleaned up old namespaces users-3908'
+ xargs kubectl delete ns
+ set +o xtrace


-----------------------------------------------------------------------------------
cleaned up old namespaces users-3908
-----------------------------------------------------------------------------------

+ kubectl_bin delete namespace users-3908
++ mktemp
++ mktemp
+ local LAST_OUT=/tmp/tmp.110Q26Knsj
+ local LAST_OUT=/tmp/tmp.tyWKjQqaUf
++ mktemp
++ mktemp
+ local LAST_ERR=/tmp/tmp.VOOYDPnPgO
+ local exit_status=0
+ local LAST_ERR=/tmp/tmp.XIYxEquJxv
+ local exit_status=0
++ seq 0 2
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl delete namespace users-3908
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl get ns
+ exit_status=1
+ set -e
+ '[' 1 '!=' 0 ']'
+ '[' 1 == 1 ']'
+ sleep 0
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl delete namespace users-3908
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.110Q26Knsj
+ cat /tmp/tmp.VOOYDPnPgO
+ rm /tmp/tmp.110Q26Knsj /tmp/tmp.VOOYDPnPgO
+ return 0
+ exit_status=1
+ set -e
+ '[' 1 '!=' 0 ']'
+ '[' 1 == 1 ']'
+ sleep 0
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl delete namespace users-3908
Error from server (Forbidden): namespaces "default" is forbidden: this namespace may not be deleted
+ exit_status=1
+ set -e
+ '[' 1 '!=' 0 ']'
+ '[' 1 == 1 ']'
+ sleep 0
+ cat /tmp/tmp.tyWKjQqaUf
+ cat /tmp/tmp.XIYxEquJxv
Error from server (NotFound): namespaces "users-3908" not found
+ rm /tmp/tmp.tyWKjQqaUf /tmp/tmp.XIYxEquJxv
+ return 1
+ :
+ wait_for_delete namespace/users-3908
+ local res=namespace/users-3908
+ echo -n 'namespace/users-3908 - '
namespace/users-3908 - + set +o xtrace
Error from server (NotFound): namespaces "users-3908" not found
+ desc 'create namespace users-3908'
+ set +o xtrace


-----------------------------------------------------------------------------------
create namespace users-3908
-----------------------------------------------------------------------------------

+ kubectl_bin create namespace users-3908
++ mktemp
+ local LAST_OUT=/tmp/tmp.CsDl5uJ6xl
++ mktemp
+ local LAST_ERR=/tmp/tmp.8fKuYA3wim
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl create namespace users-3908
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.CsDl5uJ6xl
namespace/users-3908 created
+ cat /tmp/tmp.8fKuYA3wim
+ rm /tmp/tmp.CsDl5uJ6xl /tmp/tmp.8fKuYA3wim
+ return 0
++ kubectl_bin config current-context
+++ mktemp
++ local LAST_OUT=/tmp/tmp.Yb4N5ewtRd
+++ mktemp
++ local LAST_ERR=/tmp/tmp.zGxnhO2xqP
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl config current-context
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.Yb4N5ewtRd
++ cat /tmp/tmp.zGxnhO2xqP
++ rm /tmp/tmp.Yb4N5ewtRd /tmp/tmp.zGxnhO2xqP
++ return 0
+ kubectl_bin config set-context gke_cloud-dev-112233_us-central1-a_jen-pxc-1522-1ed4605b-21-cluster3 --namespace=users-3908
++ mktemp
+ local LAST_OUT=/tmp/tmp.JcuJVqFace
++ mktemp
+ local LAST_ERR=/tmp/tmp.qzIWBWdKV8
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl config set-context gke_cloud-dev-112233_us-central1-a_jen-pxc-1522-1ed4605b-21-cluster3 --namespace=users-3908
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.JcuJVqFace
Context "gke_cloud-dev-112233_us-central1-a_jen-pxc-1522-1ed4605b-21-cluster3" modified.
+ cat /tmp/tmp.qzIWBWdKV8
+ rm /tmp/tmp.JcuJVqFace /tmp/tmp.qzIWBWdKV8
+ return 0
+ apply_secrets
+ desc 'create secrets for cloud storages'
+ set +o xtrace


-----------------------------------------------------------------------------------
create secrets for cloud storages
-----------------------------------------------------------------------------------

+ '[' -z '' ']'
+ kubectl_bin apply -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/conf/minio-secret.yml -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/conf/cloud-secret.yml
++ mktemp
+ local LAST_OUT=/tmp/tmp.9yJF5Disf5
++ mktemp
+ local LAST_ERR=/tmp/tmp.f0zAL5XyUL
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl apply -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/conf/minio-secret.yml -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/conf/cloud-secret.yml
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.9yJF5Disf5
secret/minio-secret created
secret/aws-s3-secret created
secret/gcp-cs-secret created
secret/azure-secret created
+ cat /tmp/tmp.f0zAL5XyUL
+ rm /tmp/tmp.9yJF5Disf5 /tmp/tmp.f0zAL5XyUL
+ return 0
+ desc 'create PXC cluster'
+ set +o xtrace


-----------------------------------------------------------------------------------
create PXC cluster
-----------------------------------------------------------------------------------

+ newpass=test-password
++ echo -n test-password
++ base64
+ newpassencrypted=dGVzdC1wYXNzd29yZA==
+ cluster=some-name
+ spinup_pxc some-name /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/conf/some-name.yml
+ local cluster=some-name
+ local config=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/conf/some-name.yml
+ local size=3
+ local sleep=10
+ local secretsFile=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/conf/secrets.yml
+ local pxcClientFile=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/conf/client.yml
+ local port=3306
+ desc 'create first PXC cluster'
+ set +o xtrace


-----------------------------------------------------------------------------------
create first PXC cluster
-----------------------------------------------------------------------------------

+ kubectl_bin apply -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/conf/secrets.yml
++ mktemp
+ local LAST_OUT=/tmp/tmp.bwXCj3ThfE
++ mktemp
+ local LAST_ERR=/tmp/tmp.A0hJKvSLy8
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl apply -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/conf/secrets.yml
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.bwXCj3ThfE
secret/my-cluster-secrets created
secret/some-name-ssl created
secret/some-name-ssl-internal created
+ cat /tmp/tmp.A0hJKvSLy8
+ rm /tmp/tmp.bwXCj3ThfE /tmp/tmp.A0hJKvSLy8
+ return 0
+ apply_config /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/conf/client.yml
+ '[' -z '' ']'
+ kubectl_bin apply -f -
+ cat_config /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/conf/client.yml
++ mktemp
+ local LAST_OUT=/tmp/tmp.ImboNamema
+ /usr/bin/sed -e 's#image:.*-pmm$#image: perconalab/pmm-client:dev-latest#'
+ /usr/bin/sed -e 's#image:.*-backup$#image: perconalab/percona-xtradb-cluster-operator:k8spxc-1313-8.0-backup#'
+ /usr/bin/sed -e 's#image:.*-init$#image: perconalab/percona-xtradb-cluster-operator:PR-1522-1ed4605b#'
+ /usr/bin/sed -e 's#image:.*-proxysql$#image: perconalab/percona-xtradb-cluster-operator:main-proxysql#'
+ /usr/bin/sed -e 's#image:.*\/percona-xtradb-cluster:.*$#image: perconalab/percona-xtradb-cluster-operator:main-pxc8.0#'
+ /usr/bin/sed -e 's#image:.*-pxc\([0-9]*.[0-9]*\)\{0,1\}$#image: perconalab/percona-xtradb-cluster-operator:main-pxc8.0#'
++ mktemp
+ /usr/bin/sed -e 's#apiVersion: pxc.percona.com/v.*$#apiVersion: pxc.percona.com/v1#'
+ /usr/bin/sed -e 's#image:.*-haproxy$#image: perconalab/percona-xtradb-cluster-operator:main-haproxy#'
+ local LAST_ERR=/tmp/tmp.uYuhavoMmD
+ local exit_status=0
+ cat /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/conf/client.yml
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl apply -f -
+ /usr/bin/sed -e 's#apply:.*#apply: Never#'
+ /usr/bin/sed -e s~minio-service.#namespace~minio-service.users-3908~
+ /usr/bin/sed -e 's#image:.*-logcollector$#image: perconalab/percona-xtradb-cluster-operator:main-logcollector#'
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.ImboNamema
deployment.apps/pxc-client created
+ cat /tmp/tmp.uYuhavoMmD
+ rm /tmp/tmp.ImboNamema /tmp/tmp.uYuhavoMmD
+ return 0
+ [[ perconalab/percona-xtradb-cluster-operator:main-pxc8.0 =~ 5\.7 ]]
+ apply_config /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/conf/some-name.yml
+ '[' -z '' ']'
+ cat_config /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/conf/some-name.yml
+ kubectl_bin apply -f -
+ cat /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/conf/some-name.yml
++ mktemp
+ /usr/bin/sed -e 's#image:.*-pxc\([0-9]*.[0-9]*\)\{0,1\}$#image: perconalab/percona-xtradb-cluster-operator:main-pxc8.0#'
+ /usr/bin/sed -e 's#image:.*\/percona-xtradb-cluster:.*$#image: perconalab/percona-xtradb-cluster-operator:main-pxc8.0#'
+ local LAST_OUT=/tmp/tmp.xmeCFye3so
+ /usr/bin/sed -e 's#apiVersion: pxc.percona.com/v.*$#apiVersion: pxc.percona.com/v1#'
+ /usr/bin/sed -e s~minio-service.#namespace~minio-service.users-3908~
+ /usr/bin/sed -e 's#image:.*-init$#image: perconalab/percona-xtradb-cluster-operator:PR-1522-1ed4605b#'
+ /usr/bin/sed -e 's#apply:.*#apply: Never#'
+ /usr/bin/sed -e 's#image:.*-haproxy$#image: perconalab/percona-xtradb-cluster-operator:main-haproxy#'
+ /usr/bin/sed -e 's#image:.*-proxysql$#image: perconalab/percona-xtradb-cluster-operator:main-proxysql#'
++ mktemp
+ /usr/bin/sed -e 's#image:.*-logcollector$#image: perconalab/percona-xtradb-cluster-operator:main-logcollector#'
+ /usr/bin/sed -e 's#image:.*-pmm$#image: perconalab/pmm-client:dev-latest#'
+ /usr/bin/sed -e 's#image:.*-backup$#image: perconalab/percona-xtradb-cluster-operator:k8spxc-1313-8.0-backup#'
+ local LAST_ERR=/tmp/tmp.xWjVJaFSyZ
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl apply -f -
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.xmeCFye3so
perconaxtradbcluster.pxc.percona.com/some-name created
+ cat /tmp/tmp.xWjVJaFSyZ
+ rm /tmp/tmp.xmeCFye3so /tmp/tmp.xWjVJaFSyZ
+ return 0
+ desc 'check if all 3 Pods started'
+ set +o xtrace


-----------------------------------------------------------------------------------
check if all 3 Pods started
-----------------------------------------------------------------------------------

++ get_proxy some-name
++ local target_cluster=some-name
+++ kubectl_bin get pxc some-name -o 'jsonpath={.spec.haproxy.enabled}'
++++ mktemp
+++ local LAST_OUT=/tmp/tmp.BnbTPCRGwF
++++ mktemp
+++ local LAST_ERR=/tmp/tmp.dFeS86G8em
+++ local exit_status=0
++++ seq 0 2
+++ for i in '$(seq 0 2)'
+++ set +e
+++ kubectl get pxc some-name -o 'jsonpath={.spec.haproxy.enabled}'
+++ exit_status=0
+++ set -e
+++ '[' 0 '!=' 0 ']'
+++ break
+++ cat /tmp/tmp.BnbTPCRGwF
+++ cat /tmp/tmp.dFeS86G8em
+++ rm /tmp/tmp.BnbTPCRGwF /tmp/tmp.dFeS86G8em
+++ return 0
++ [[ '' == \t\r\u\e ]]
+++ kubectl_bin get pxc some-name -o 'jsonpath={.spec.proxysql.enabled}'
++++ mktemp
+++ local LAST_OUT=/tmp/tmp.A24OrEduAy
++++ mktemp
+++ local LAST_ERR=/tmp/tmp.CZH1fOymf9
+++ local exit_status=0
++++ seq 0 2
+++ for i in '$(seq 0 2)'
+++ set +e
+++ kubectl get pxc some-name -o 'jsonpath={.spec.proxysql.enabled}'
+++ exit_status=0
+++ set -e
+++ '[' 0 '!=' 0 ']'
+++ break
+++ cat /tmp/tmp.A24OrEduAy
+++ cat /tmp/tmp.CZH1fOymf9
+++ rm /tmp/tmp.A24OrEduAy /tmp/tmp.CZH1fOymf9
+++ return 0
++ [[ true == \t\r\u\e ]]
++ echo some-name-proxysql
++ return
+ local proxy=some-name-proxysql
+ kubectl_bin wait --for=condition=Ready pod -l app.kubernetes.io/instance=monitoring,app.kubernetes.io/managed-by=percona-xtradb-cluster-operator --timeout=300s -n users-3908
++ mktemp
+ local LAST_OUT=/tmp/tmp.O3FSepOoLy
++ mktemp
+ local LAST_ERR=/tmp/tmp.sgfaG7oyf8
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl wait --for=condition=Ready pod -l app.kubernetes.io/instance=monitoring,app.kubernetes.io/managed-by=percona-xtradb-cluster-operator --timeout=300s -n users-3908
+ exit_status=1
+ set -e
+ '[' 1 '!=' 0 ']'
+ '[' 1 == 1 ']'
+ sleep 0
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl wait --for=condition=Ready pod -l app.kubernetes.io/instance=monitoring,app.kubernetes.io/managed-by=percona-xtradb-cluster-operator --timeout=300s -n users-3908
+ exit_status=1
+ set -e
+ '[' 1 '!=' 0 ']'
+ '[' 1 == 1 ']'
+ sleep 0
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl wait --for=condition=Ready pod -l app.kubernetes.io/instance=monitoring,app.kubernetes.io/managed-by=percona-xtradb-cluster-operator --timeout=300s -n users-3908
+ exit_status=1
+ set -e
+ '[' 1 '!=' 0 ']'
+ '[' 1 == 1 ']'
+ sleep 0
+ cat /tmp/tmp.O3FSepOoLy
+ cat /tmp/tmp.sgfaG7oyf8
error: no matching resources found
+ rm /tmp/tmp.O3FSepOoLy /tmp/tmp.sgfaG7oyf8
+ return 1
+ true
+ wait_for_running some-name-proxysql 1
+ local name=some-name-proxysql
+ let last_pod=0
+ :
+ local max_retry=480
+ desc 'wait for running cluster'
+ set +o xtrace


-----------------------------------------------------------------------------------
wait for running cluster
-----------------------------------------------------------------------------------

++ seq 0 0
+ for i in '$(seq 0 $last_pod)'
+ wait_pod some-name-proxysql-0 480
+ local pod=some-name-proxysql-0
+ local max_retry=480
+ local ns=
++ echo some-name-proxysql-0
++ egrep '^(pxc|proxysql)$'
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
+ local container=proxysql
+ set +o xtrace
pod/some-name-proxysql-0 condition met
some-name-proxysql-0.Ok
+ wait_for_running some-name-pxc 3
+ local name=some-name-pxc
+ let last_pod=2
+ local max_retry=480
+ desc 'wait for running cluster'
+ set +o xtrace


-----------------------------------------------------------------------------------
wait for running cluster
-----------------------------------------------------------------------------------

++ seq 0 2
+ for i in '$(seq 0 $last_pod)'
+ wait_pod some-name-pxc-0 480
+ local pod=some-name-pxc-0
+ local max_retry=480
+ local ns=
++ echo some-name-pxc-0
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=pxc
+ set +o xtrace
pod/some-name-pxc-0 condition met
some-name-pxc-0.Ok
+ for i in '$(seq 0 $last_pod)'
+ wait_pod some-name-pxc-1 480
+ local pod=some-name-pxc-1
+ local max_retry=480
+ local ns=
++ echo some-name-pxc-1
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=pxc
+ set +o xtrace
pod/some-name-pxc-1 condition met
some-name-pxc-1.Ok
+ for i in '$(seq 0 $last_pod)'
+ wait_pod some-name-pxc-2 480
+ local pod=some-name-pxc-2
+ local max_retry=480
+ local ns=
++ echo some-name-pxc-2
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=pxc
+ set +o xtrace
pod/some-name-pxc-2 condition met
some-name-pxc-2.Ok
+ sleep 10
+ desc 'write data'
+ set +o xtrace


-----------------------------------------------------------------------------------
write data
-----------------------------------------------------------------------------------

+ [[ perconalab/percona-xtradb-cluster-operator:main-pxc8.0 =~ 5\.7 ]]
+ run_mysql 'CREATE DATABASE IF NOT EXISTS myApp; use myApp; CREATE TABLE IF NOT EXISTS myApp (id int PRIMARY KEY) ;' '-h some-name-proxysql -uroot -proot_password -P3306'
+ local 'command=CREATE DATABASE IF NOT EXISTS myApp; use myApp; CREATE TABLE IF NOT EXISTS myApp (id int PRIMARY KEY) ;'
+ local 'uri=-h some-name-proxysql -uroot -proot_password -P3306'
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.MF5m01Yk3j
+++ mktemp
++ local LAST_ERR=/tmp/tmp.lyJa0twOO7
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.MF5m01Yk3j
++ cat /tmp/tmp.lyJa0twOO7
++ rm /tmp/tmp.MF5m01Yk3j /tmp/tmp.lyJa0twOO7
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ run_mysql 'INSERT myApp.myApp (id) VALUES (100500)' '-h some-name-proxysql -uroot -proot_password -P3306'
+ local 'command=INSERT myApp.myApp (id) VALUES (100500)'
+ local 'uri=-h some-name-proxysql -uroot -proot_password -P3306'
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.ZXivWeihmu
+++ mktemp
++ local LAST_ERR=/tmp/tmp.HYnKYipHyH
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.ZXivWeihmu
++ cat /tmp/tmp.HYnKYipHyH
++ rm /tmp/tmp.ZXivWeihmu /tmp/tmp.HYnKYipHyH
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ sleep 30
++ seq 0 2
+ for i in '$(seq 0 $((size - 1)))'
+ compare_mysql_cmd select-1 'SELECT * from myApp.myApp;' '-h some-name-pxc-0.some-name-pxc -uroot -proot_password -P3306'
+ local command_id=select-1
+ local 'command=SELECT * from myApp.myApp;'
+ local 'uri=-h some-name-pxc-0.some-name-pxc -uroot -proot_password -P3306'
+ local postfix=
+ local expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-1.sql
+ [[ perconalab/percona-xtradb-cluster-operator:main-pxc8.0 =~ 8\.0 ]]
+ '[' -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-1-80.sql ']'
+ run_mysql 'SELECT * from myApp.myApp;' '-h some-name-pxc-0.some-name-pxc -uroot -proot_password -P3306'
+ local 'command=SELECT * from myApp.myApp;'
+ local 'uri=-h some-name-pxc-0.some-name-pxc -uroot -proot_password -P3306'
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.ToVKLjEdsJ
+++ mktemp
++ local LAST_ERR=/tmp/tmp.2uGKKnuq5Q
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.ToVKLjEdsJ
++ cat /tmp/tmp.2uGKKnuq5Q
++ rm /tmp/tmp.ToVKLjEdsJ /tmp/tmp.2uGKKnuq5Q
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ '[' '!' -s /tmp/tmp.HdChWhA5Fm/select-1.sql ']'
+ diff -u /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-1.sql /tmp/tmp.HdChWhA5Fm/select-1.sql
+ for i in '$(seq 0 $((size - 1)))'
+ compare_mysql_cmd select-1 'SELECT * from myApp.myApp;' '-h some-name-pxc-1.some-name-pxc -uroot -proot_password -P3306'
+ local command_id=select-1
+ local 'command=SELECT * from myApp.myApp;'
+ local 'uri=-h some-name-pxc-1.some-name-pxc -uroot -proot_password -P3306'
+ local postfix=
+ local expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-1.sql
+ [[ perconalab/percona-xtradb-cluster-operator:main-pxc8.0 =~ 8\.0 ]]
+ '[' -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-1-80.sql ']'
+ run_mysql 'SELECT * from myApp.myApp;' '-h some-name-pxc-1.some-name-pxc -uroot -proot_password -P3306'
+ local 'command=SELECT * from myApp.myApp;'
+ local 'uri=-h some-name-pxc-1.some-name-pxc -uroot -proot_password -P3306'
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.SElcbuRVwU
+++ mktemp
++ local LAST_ERR=/tmp/tmp.HuXJWMZoi3
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.SElcbuRVwU
++ cat /tmp/tmp.HuXJWMZoi3
++ rm /tmp/tmp.SElcbuRVwU /tmp/tmp.HuXJWMZoi3
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ '[' '!' -s /tmp/tmp.HdChWhA5Fm/select-1.sql ']'
+ diff -u /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-1.sql /tmp/tmp.HdChWhA5Fm/select-1.sql
+ for i in '$(seq 0 $((size - 1)))'
+ compare_mysql_cmd select-1 'SELECT * from myApp.myApp;' '-h some-name-pxc-2.some-name-pxc -uroot -proot_password -P3306'
+ local command_id=select-1
+ local 'command=SELECT * from myApp.myApp;'
+ local 'uri=-h some-name-pxc-2.some-name-pxc -uroot -proot_password -P3306'
+ local postfix=
+ local expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-1.sql
+ [[ perconalab/percona-xtradb-cluster-operator:main-pxc8.0 =~ 8\.0 ]]
+ '[' -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-1-80.sql ']'
+ run_mysql 'SELECT * from myApp.myApp;' '-h some-name-pxc-2.some-name-pxc -uroot -proot_password -P3306'
+ local 'command=SELECT * from myApp.myApp;'
+ local 'uri=-h some-name-pxc-2.some-name-pxc -uroot -proot_password -P3306'
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.z8NZIIHtuc
+++ mktemp
++ local LAST_ERR=/tmp/tmp.KeTOPrEtBU
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.z8NZIIHtuc
++ cat /tmp/tmp.KeTOPrEtBU
++ rm /tmp/tmp.z8NZIIHtuc /tmp/tmp.KeTOPrEtBU
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ '[' '!' -s /tmp/tmp.HdChWhA5Fm/select-1.sql ']'
+ diff -u /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-1.sql /tmp/tmp.HdChWhA5Fm/select-1.sql
++ is_keyring_plugin_in_use some-name
++ local cluster=some-name
++ kubectl_bin exec -it some-name-pxc-0 -c pxc -- bash -c 'cat /etc/mysql/node.cnf'
++ egrep -o 'early-plugin-load=keyring_\w+.so'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.ZQlaDVwWOa
+++ mktemp
++ local LAST_ERR=/tmp/tmp.YTxQbEW3Rz
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl exec -it some-name-pxc-0 -c pxc -- bash -c 'cat /etc/mysql/node.cnf'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.ZQlaDVwWOa
++ cat /tmp/tmp.YTxQbEW3Rz
Unable to use a TTY - input is not a terminal or the right kind of file
++ rm /tmp/tmp.ZQlaDVwWOa /tmp/tmp.YTxQbEW3Rz
++ return 0
+ '[' '' ']'
+ desc 'test root'
+ set +o xtrace


-----------------------------------------------------------------------------------
test root
-----------------------------------------------------------------------------------

+ patch_secret my-cluster-secrets root dGVzdC1wYXNzd29yZA==
+ local secret=my-cluster-secrets
+ local key=root
+ local value=dGVzdC1wYXNzd29yZA==
+ kubectl_bin patch secret my-cluster-secrets '-p={"data":{"root": "dGVzdC1wYXNzd29yZA=="}}'
++ mktemp
+ local LAST_OUT=/tmp/tmp.CWmP1YHwEM
++ mktemp
+ local LAST_ERR=/tmp/tmp.YfRlj2dKil
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl patch secret my-cluster-secrets '-p={"data":{"root": "dGVzdC1wYXNzd29yZA=="}}'
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.CWmP1YHwEM
secret/my-cluster-secrets patched
+ cat /tmp/tmp.YfRlj2dKil
+ rm /tmp/tmp.CWmP1YHwEM /tmp/tmp.YfRlj2dKil
+ return 0
+ sleep 15
+ compare_mysql_cmd select-4 'SHOW TABLES;' '-h some-name-proxysql -uroot -p'\''test-password'\'''
+ local command_id=select-4
+ local 'command=SHOW TABLES;'
+ local 'uri=-h some-name-proxysql -uroot -p'\''test-password'\'''
+ local postfix=
+ local expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4.sql
+ [[ perconalab/percona-xtradb-cluster-operator:main-pxc8.0 =~ 8\.0 ]]
+ '[' -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4-80.sql ']'
+ expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4-80.sql
+ run_mysql 'SHOW TABLES;' '-h some-name-proxysql -uroot -p'\''test-password'\'''
+ local 'command=SHOW TABLES;'
+ local 'uri=-h some-name-proxysql -uroot -p'\''test-password'\'''
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.1IvJ6I8DFH
+++ mktemp
++ local LAST_ERR=/tmp/tmp.EOqE7sgf2x
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.1IvJ6I8DFH
++ cat /tmp/tmp.EOqE7sgf2x
++ rm /tmp/tmp.1IvJ6I8DFH /tmp/tmp.EOqE7sgf2x
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ egrep '^(pxc|proxysql)$'
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ '[' '!' -s /tmp/tmp.HdChWhA5Fm/select-4.sql ']'
+ diff -u /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4-80.sql /tmp/tmp.HdChWhA5Fm/select-4.sql
+ desc 'test proxyadmin'
+ set +o xtrace


-----------------------------------------------------------------------------------
test proxyadmin
-----------------------------------------------------------------------------------

+ kubectl_bin patch pxc some-name --type=merge '-p={"spec":{"proxysql":{"size":3}}}'
++ mktemp
+ local LAST_OUT=/tmp/tmp.VeRHEt5x6z
++ mktemp
+ local LAST_ERR=/tmp/tmp.SEJemw9jJL
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl patch pxc some-name --type=merge '-p={"spec":{"proxysql":{"size":3}}}'
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.VeRHEt5x6z
perconaxtradbcluster.pxc.percona.com/some-name patched
+ cat /tmp/tmp.SEJemw9jJL
+ rm /tmp/tmp.VeRHEt5x6z /tmp/tmp.SEJemw9jJL
+ return 0
+ sleep 15
+ wait_cluster_consistency some-name 3 3
+ local cluster_name=some-name
+ local cluster_size=3
+ local proxy_size=3
+ '[' -z 3 ']'
+ desc 'wait cluster consistency'
+ set +o xtrace


-----------------------------------------------------------------------------------
wait cluster consistency
-----------------------------------------------------------------------------------

+ sleep 7
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.F9E21ORwCV
+++ mktemp
++ local LAST_ERR=/tmp/tmp.BH1MDjy8W5
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.F9E21ORwCV
++ cat /tmp/tmp.BH1MDjy8W5
++ rm /tmp/tmp.F9E21ORwCV /tmp/tmp.BH1MDjy8W5
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.M1q3OLhc4I
+++ mktemp
++ local LAST_ERR=/tmp/tmp.f7A9YIH9YB
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.M1q3OLhc4I
++ cat /tmp/tmp.f7A9YIH9YB
++ rm /tmp/tmp.M1q3OLhc4I /tmp/tmp.f7A9YIH9YB
++ return 0
+ [[ ready == \r\e\a\d\y ]]
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.pxc.ready}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.itZXMznhrP
+++ mktemp
++ local LAST_ERR=/tmp/tmp.Ze6GZ2gptW
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.pxc.ready}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.itZXMznhrP
++ cat /tmp/tmp.Ze6GZ2gptW
++ rm /tmp/tmp.itZXMznhrP /tmp/tmp.Ze6GZ2gptW
++ return 0
+ [[ 3 == \3 ]]
+++ get_proxy_engine some-name
+++ local cluster_name=some-name
++++ get_proxy some-name
++++ local target_cluster=some-name
+++++ kubectl_bin get pxc some-name -o 'jsonpath={.spec.haproxy.enabled}'
++++++ mktemp
+++++ local LAST_OUT=/tmp/tmp.cWQSPCpO6t
++++++ mktemp
+++++ local LAST_ERR=/tmp/tmp.ERNiDwKatl
+++++ local exit_status=0
++++++ seq 0 2
+++++ for i in '$(seq 0 2)'
+++++ set +e
+++++ kubectl get pxc some-name -o 'jsonpath={.spec.haproxy.enabled}'
+++++ exit_status=0
+++++ set -e
+++++ '[' 0 '!=' 0 ']'
+++++ break
+++++ cat /tmp/tmp.cWQSPCpO6t
+++++ cat /tmp/tmp.ERNiDwKatl
+++++ rm /tmp/tmp.cWQSPCpO6t /tmp/tmp.ERNiDwKatl
+++++ return 0
++++ [[ '' == \t\r\u\e ]]
+++++ kubectl_bin get pxc some-name -o 'jsonpath={.spec.proxysql.enabled}'
++++++ mktemp
+++++ local LAST_OUT=/tmp/tmp.M5QuajaQeA
++++++ mktemp
+++++ local LAST_ERR=/tmp/tmp.CGIgchx4Kx
+++++ local exit_status=0
++++++ seq 0 2
+++++ for i in '$(seq 0 2)'
+++++ set +e
+++++ kubectl get pxc some-name -o 'jsonpath={.spec.proxysql.enabled}'
+++++ exit_status=0
+++++ set -e
+++++ '[' 0 '!=' 0 ']'
+++++ break
+++++ cat /tmp/tmp.M5QuajaQeA
+++++ cat /tmp/tmp.CGIgchx4Kx
+++++ rm /tmp/tmp.M5QuajaQeA /tmp/tmp.CGIgchx4Kx
+++++ return 0
++++ [[ true == \t\r\u\e ]]
++++ echo some-name-proxysql
++++ return
+++ local cluster_proxy=some-name-proxysql
+++ echo proxysql
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.proxysql.ready}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.HlzW6pzOhK
+++ mktemp
++ local LAST_ERR=/tmp/tmp.45tygkwd4o
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.proxysql.ready}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.HlzW6pzOhK
++ cat /tmp/tmp.45tygkwd4o
++ rm /tmp/tmp.HlzW6pzOhK /tmp/tmp.45tygkwd4o
++ return 0
+ [[ 3 == \3 ]]
+ patch_secret my-cluster-secrets proxyadmin dGVzdC1wYXNzd29yZA==
+ local secret=my-cluster-secrets
+ local key=proxyadmin
+ local value=dGVzdC1wYXNzd29yZA==
+ kubectl_bin patch secret my-cluster-secrets '-p={"data":{"proxyadmin": "dGVzdC1wYXNzd29yZA=="}}'
++ mktemp
+ local LAST_OUT=/tmp/tmp.Jzz9Loamm4
++ mktemp
+ local LAST_ERR=/tmp/tmp.QC8wnjKm2L
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl patch secret my-cluster-secrets '-p={"data":{"proxyadmin": "dGVzdC1wYXNzd29yZA=="}}'
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.Jzz9Loamm4
secret/my-cluster-secrets patched
+ cat /tmp/tmp.QC8wnjKm2L
+ rm /tmp/tmp.Jzz9Loamm4 /tmp/tmp.QC8wnjKm2L
+ return 0
+ sleep 15
+ wait_cluster_consistency some-name 3 3
+ local cluster_name=some-name
+ local cluster_size=3
+ local proxy_size=3
+ '[' -z 3 ']'
+ desc 'wait cluster consistency'
+ set +o xtrace


-----------------------------------------------------------------------------------
wait cluster consistency
-----------------------------------------------------------------------------------

+ sleep 7
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.kuqznZz3dY
+++ mktemp
++ local LAST_ERR=/tmp/tmp.jh6VRfTtIN
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.kuqznZz3dY
++ cat /tmp/tmp.jh6VRfTtIN
++ rm /tmp/tmp.kuqznZz3dY /tmp/tmp.jh6VRfTtIN
++ return 0
+ [[ initializing == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.2ixEtfRj3E
+++ mktemp
++ local LAST_ERR=/tmp/tmp.cAsS022Z1f
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.2ixEtfRj3E
++ cat /tmp/tmp.cAsS022Z1f
++ rm /tmp/tmp.2ixEtfRj3E /tmp/tmp.cAsS022Z1f
++ return 0
+ [[ ready == \r\e\a\d\y ]]
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.pxc.ready}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.0du0F4Q1dv
+++ mktemp
++ local LAST_ERR=/tmp/tmp.sayIkVvKNb
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.pxc.ready}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.0du0F4Q1dv
++ cat /tmp/tmp.sayIkVvKNb
++ rm /tmp/tmp.0du0F4Q1dv /tmp/tmp.sayIkVvKNb
++ return 0
+ [[ 3 == \3 ]]
+++ get_proxy_engine some-name
+++ local cluster_name=some-name
++++ get_proxy some-name
++++ local target_cluster=some-name
+++++ kubectl_bin get pxc some-name -o 'jsonpath={.spec.haproxy.enabled}'
++++++ mktemp
+++++ local LAST_OUT=/tmp/tmp.LWYdevsM1v
++++++ mktemp
+++++ local LAST_ERR=/tmp/tmp.GY3a0v6PsW
+++++ local exit_status=0
++++++ seq 0 2
+++++ for i in '$(seq 0 2)'
+++++ set +e
+++++ kubectl get pxc some-name -o 'jsonpath={.spec.haproxy.enabled}'
+++++ exit_status=0
+++++ set -e
+++++ '[' 0 '!=' 0 ']'
+++++ break
+++++ cat /tmp/tmp.LWYdevsM1v
+++++ cat /tmp/tmp.GY3a0v6PsW
+++++ rm /tmp/tmp.LWYdevsM1v /tmp/tmp.GY3a0v6PsW
+++++ return 0
++++ [[ '' == \t\r\u\e ]]
+++++ kubectl_bin get pxc some-name -o 'jsonpath={.spec.proxysql.enabled}'
++++++ mktemp
+++++ local LAST_OUT=/tmp/tmp.35M6uIzWvQ
++++++ mktemp
+++++ local LAST_ERR=/tmp/tmp.EX0ayWyEeJ
+++++ local exit_status=0
++++++ seq 0 2
+++++ for i in '$(seq 0 2)'
+++++ set +e
+++++ kubectl get pxc some-name -o 'jsonpath={.spec.proxysql.enabled}'
+++++ exit_status=0
+++++ set -e
+++++ '[' 0 '!=' 0 ']'
+++++ break
+++++ cat /tmp/tmp.35M6uIzWvQ
+++++ cat /tmp/tmp.EX0ayWyEeJ
+++++ rm /tmp/tmp.35M6uIzWvQ /tmp/tmp.EX0ayWyEeJ
+++++ return 0
++++ [[ true == \t\r\u\e ]]
++++ echo some-name-proxysql
++++ return
+++ local cluster_proxy=some-name-proxysql
+++ echo proxysql
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.proxysql.ready}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.594EJvSIoS
+++ mktemp
++ local LAST_ERR=/tmp/tmp.lRcVjRK365
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.proxysql.ready}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.594EJvSIoS
++ cat /tmp/tmp.lRcVjRK365
++ rm /tmp/tmp.594EJvSIoS /tmp/tmp.lRcVjRK365
++ return 0
+ [[ 3 == \3 ]]
+ compare_mysql_cmd_local select-2 'SHOW TABLES;' '-h127.0.0.1 -P6032 -uproxyadmin -p'\''test-password'\''' some-name-proxysql-0 '' proxysql
+ local command_id=select-2
+ local 'command=SHOW TABLES;'
+ local 'uri=-h127.0.0.1 -P6032 -uproxyadmin -p'\''test-password'\'''
+ local pod=some-name-proxysql-0
+ local postfix=
+ local container_name=proxysql
+ local expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-2.sql
+ [[ perconalab/percona-xtradb-cluster-operator:main-pxc8.0 =~ 8\.0 ]]
+ '[' -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-2-80.sql ']'
+ run_mysql_local 'SHOW TABLES;' '-h127.0.0.1 -P6032 -uproxyadmin -p'\''test-password'\''' some-name-proxysql-0 proxysql
+ local 'command=SHOW TABLES;'
+ local 'uri=-h127.0.0.1 -P6032 -uproxyadmin -p'\''test-password'\'''
+ local pod=some-name-proxysql-0
+ local container_name=proxysql
+ set +o xtrace
+ '[' '!' -s /tmp/tmp.HdChWhA5Fm/select-2.sql ']'
+ diff -u /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-2.sql /tmp/tmp.HdChWhA5Fm/select-2.sql
+ compare_mysql_cmd_local select-2 'SHOW TABLES;' '-h127.0.0.1 -P6032 -uproxyadmin -p'\''test-password'\''' some-name-proxysql-1 '' proxysql
+ local command_id=select-2
+ local 'command=SHOW TABLES;'
+ local 'uri=-h127.0.0.1 -P6032 -uproxyadmin -p'\''test-password'\'''
+ local pod=some-name-proxysql-1
+ local postfix=
+ local container_name=proxysql
+ local expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-2.sql
+ [[ perconalab/percona-xtradb-cluster-operator:main-pxc8.0 =~ 8\.0 ]]
+ '[' -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-2-80.sql ']'
+ run_mysql_local 'SHOW TABLES;' '-h127.0.0.1 -P6032 -uproxyadmin -p'\''test-password'\''' some-name-proxysql-1 proxysql
+ local 'command=SHOW TABLES;'
+ local 'uri=-h127.0.0.1 -P6032 -uproxyadmin -p'\''test-password'\'''
+ local pod=some-name-proxysql-1
+ local container_name=proxysql
+ set +o xtrace
+ '[' '!' -s /tmp/tmp.HdChWhA5Fm/select-2.sql ']'
+ diff -u /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-2.sql /tmp/tmp.HdChWhA5Fm/select-2.sql
+ compare_mysql_cmd_local select-2 'SHOW TABLES;' '-h127.0.0.1 -P6032 -uproxyadmin -p'\''test-password'\''' some-name-proxysql-2 '' proxysql
+ local command_id=select-2
+ local 'command=SHOW TABLES;'
+ local 'uri=-h127.0.0.1 -P6032 -uproxyadmin -p'\''test-password'\'''
+ local pod=some-name-proxysql-2
+ local postfix=
+ local container_name=proxysql
+ local expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-2.sql
+ [[ perconalab/percona-xtradb-cluster-operator:main-pxc8.0 =~ 8\.0 ]]
+ '[' -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-2-80.sql ']'
+ run_mysql_local 'SHOW TABLES;' '-h127.0.0.1 -P6032 -uproxyadmin -p'\''test-password'\''' some-name-proxysql-2 proxysql
+ local 'command=SHOW TABLES;'
+ local 'uri=-h127.0.0.1 -P6032 -uproxyadmin -p'\''test-password'\'''
+ local pod=some-name-proxysql-2
+ local container_name=proxysql
+ set +o xtrace
+ '[' '!' -s /tmp/tmp.HdChWhA5Fm/select-2.sql ']'
+ diff -u /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-2.sql /tmp/tmp.HdChWhA5Fm/select-2.sql
+ desc 'test xtrabackup'
+ set +o xtrace


-----------------------------------------------------------------------------------
test xtrabackup
-----------------------------------------------------------------------------------

+ kubectl_bin patch pxc some-name --type=merge '-p={"spec":{"proxysql":{"size":2}}}'
++ mktemp
+ local LAST_OUT=/tmp/tmp.kZjCVe3ZJc
++ mktemp
+ local LAST_ERR=/tmp/tmp.XGe1aPo2Om
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl patch pxc some-name --type=merge '-p={"spec":{"proxysql":{"size":2}}}'
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.kZjCVe3ZJc
perconaxtradbcluster.pxc.percona.com/some-name patched
+ cat /tmp/tmp.XGe1aPo2Om
+ rm /tmp/tmp.kZjCVe3ZJc /tmp/tmp.XGe1aPo2Om
+ return 0
+ patch_secret my-cluster-secrets xtrabackup dGVzdC1wYXNzd29yZA==
+ local secret=my-cluster-secrets
+ local key=xtrabackup
+ local value=dGVzdC1wYXNzd29yZA==
+ kubectl_bin patch secret my-cluster-secrets '-p={"data":{"xtrabackup": "dGVzdC1wYXNzd29yZA=="}}'
++ mktemp
+ local LAST_OUT=/tmp/tmp.l88zbWlLWs
++ mktemp
+ local LAST_ERR=/tmp/tmp.FpCsduqOdZ
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl patch secret my-cluster-secrets '-p={"data":{"xtrabackup": "dGVzdC1wYXNzd29yZA=="}}'
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.l88zbWlLWs
secret/my-cluster-secrets patched
+ cat /tmp/tmp.FpCsduqOdZ
+ rm /tmp/tmp.l88zbWlLWs /tmp/tmp.FpCsduqOdZ
+ return 0
+ sleep 15
+ wait_cluster_consistency some-name 3 2
+ local cluster_name=some-name
+ local cluster_size=3
+ local proxy_size=2
+ '[' -z 2 ']'
+ desc 'wait cluster consistency'
+ set +o xtrace


-----------------------------------------------------------------------------------
wait cluster consistency
-----------------------------------------------------------------------------------

+ sleep 7
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.fTBkW7CPG9
+++ mktemp
++ local LAST_ERR=/tmp/tmp.KOZ7VxfVKp
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.fTBkW7CPG9
++ cat /tmp/tmp.KOZ7VxfVKp
++ rm /tmp/tmp.fTBkW7CPG9 /tmp/tmp.KOZ7VxfVKp
++ return 0
+ [[ initializing == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.lZZDQXz0iU
+++ mktemp
++ local LAST_ERR=/tmp/tmp.YgpgIeGoMX
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.lZZDQXz0iU
++ cat /tmp/tmp.YgpgIeGoMX
++ rm /tmp/tmp.lZZDQXz0iU /tmp/tmp.YgpgIeGoMX
++ return 0
+ [[ initializing == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.8QJnkdqisB
+++ mktemp
++ local LAST_ERR=/tmp/tmp.lvLJZvnq2N
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.8QJnkdqisB
++ cat /tmp/tmp.lvLJZvnq2N
++ rm /tmp/tmp.8QJnkdqisB /tmp/tmp.lvLJZvnq2N
++ return 0
+ [[ initializing == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.3Ks6hRn77H
+++ mktemp
++ local LAST_ERR=/tmp/tmp.wvMzjnpRoG
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.3Ks6hRn77H
++ cat /tmp/tmp.wvMzjnpRoG
++ rm /tmp/tmp.3Ks6hRn77H /tmp/tmp.wvMzjnpRoG
++ return 0
+ [[ initializing == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.RC94Y5YAUr
+++ mktemp
++ local LAST_ERR=/tmp/tmp.tWWKMUVDPT
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.RC94Y5YAUr
++ cat /tmp/tmp.tWWKMUVDPT
++ rm /tmp/tmp.RC94Y5YAUr /tmp/tmp.tWWKMUVDPT
++ return 0
+ [[ initializing == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.0WdgTwrmTt
+++ mktemp
++ local LAST_ERR=/tmp/tmp.gIRNFP57Mz
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.0WdgTwrmTt
++ cat /tmp/tmp.gIRNFP57Mz
++ rm /tmp/tmp.0WdgTwrmTt /tmp/tmp.gIRNFP57Mz
++ return 0
+ [[ initializing == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.dqEgjXdZSd
+++ mktemp
++ local LAST_ERR=/tmp/tmp.lnSTBXW0r7
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.dqEgjXdZSd
++ cat /tmp/tmp.lnSTBXW0r7
++ rm /tmp/tmp.dqEgjXdZSd /tmp/tmp.lnSTBXW0r7
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.eStLO4FlNp
+++ mktemp
++ local LAST_ERR=/tmp/tmp.5r9xIT9CFH
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.eStLO4FlNp
++ cat /tmp/tmp.5r9xIT9CFH
++ rm /tmp/tmp.eStLO4FlNp /tmp/tmp.5r9xIT9CFH
++ return 0
+ [[ initializing == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.r74mBsUUeR
+++ mktemp
++ local LAST_ERR=/tmp/tmp.aPqBT56f7v
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.r74mBsUUeR
++ cat /tmp/tmp.aPqBT56f7v
++ rm /tmp/tmp.r74mBsUUeR /tmp/tmp.aPqBT56f7v
++ return 0
+ [[ ready == \r\e\a\d\y ]]
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.pxc.ready}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.N02hODYsNw
+++ mktemp
++ local LAST_ERR=/tmp/tmp.A9TLuyFOdY
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.pxc.ready}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.N02hODYsNw
++ cat /tmp/tmp.A9TLuyFOdY
++ rm /tmp/tmp.N02hODYsNw /tmp/tmp.A9TLuyFOdY
++ return 0
+ [[ 3 == \3 ]]
+++ get_proxy_engine some-name
+++ local cluster_name=some-name
++++ get_proxy some-name
++++ local target_cluster=some-name
+++++ kubectl_bin get pxc some-name -o 'jsonpath={.spec.haproxy.enabled}'
++++++ mktemp
+++++ local LAST_OUT=/tmp/tmp.RA1QB64g3B
++++++ mktemp
+++++ local LAST_ERR=/tmp/tmp.8a9Vt32KR4
+++++ local exit_status=0
++++++ seq 0 2
+++++ for i in '$(seq 0 2)'
+++++ set +e
+++++ kubectl get pxc some-name -o 'jsonpath={.spec.haproxy.enabled}'
+++++ exit_status=0
+++++ set -e
+++++ '[' 0 '!=' 0 ']'
+++++ break
+++++ cat /tmp/tmp.RA1QB64g3B
+++++ cat /tmp/tmp.8a9Vt32KR4
+++++ rm /tmp/tmp.RA1QB64g3B /tmp/tmp.8a9Vt32KR4
+++++ return 0
++++ [[ '' == \t\r\u\e ]]
+++++ kubectl_bin get pxc some-name -o 'jsonpath={.spec.proxysql.enabled}'
++++++ mktemp
+++++ local LAST_OUT=/tmp/tmp.ModOftkVFq
++++++ mktemp
+++++ local LAST_ERR=/tmp/tmp.7y8aQLV6KZ
+++++ local exit_status=0
++++++ seq 0 2
+++++ for i in '$(seq 0 2)'
+++++ set +e
+++++ kubectl get pxc some-name -o 'jsonpath={.spec.proxysql.enabled}'
+++++ exit_status=0
+++++ set -e
+++++ '[' 0 '!=' 0 ']'
+++++ break
+++++ cat /tmp/tmp.ModOftkVFq
+++++ cat /tmp/tmp.7y8aQLV6KZ
+++++ rm /tmp/tmp.ModOftkVFq /tmp/tmp.7y8aQLV6KZ
+++++ return 0
++++ [[ true == \t\r\u\e ]]
++++ echo some-name-proxysql
++++ return
+++ local cluster_proxy=some-name-proxysql
+++ echo proxysql
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.proxysql.ready}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.onzLkpUSTG
+++ mktemp
++ local LAST_ERR=/tmp/tmp.7Y40knnE5E
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.proxysql.ready}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.onzLkpUSTG
++ cat /tmp/tmp.7Y40knnE5E
++ rm /tmp/tmp.onzLkpUSTG /tmp/tmp.7Y40knnE5E
++ return 0
+ [[ 2 == \2 ]]
+ compare_mysql_cmd_local select-3 'SHOW DATABASES;' '-h 127.0.0.1 -uxtrabackup -p'\''test-password'\''' some-name-pxc-0 '' pxc
+ local command_id=select-3
+ local 'command=SHOW DATABASES;'
+ local 'uri=-h 127.0.0.1 -uxtrabackup -p'\''test-password'\'''
+ local pod=some-name-pxc-0
+ local postfix=
+ local container_name=pxc
+ local expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-3.sql
+ [[ perconalab/percona-xtradb-cluster-operator:main-pxc8.0 =~ 8\.0 ]]
+ '[' -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-3-80.sql ']'
+ run_mysql_local 'SHOW DATABASES;' '-h 127.0.0.1 -uxtrabackup -p'\''test-password'\''' some-name-pxc-0 pxc
+ local 'command=SHOW DATABASES;'
+ local 'uri=-h 127.0.0.1 -uxtrabackup -p'\''test-password'\'''
+ local pod=some-name-pxc-0
+ local container_name=pxc
+ set +o xtrace
+ '[' '!' -s /tmp/tmp.HdChWhA5Fm/select-3.sql ']'
+ diff -u /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-3.sql /tmp/tmp.HdChWhA5Fm/select-3.sql
+ desc 'test monitor'
+ set +o xtrace


-----------------------------------------------------------------------------------
test monitor
-----------------------------------------------------------------------------------

+ patch_secret my-cluster-secrets monitor dGVzdC1wYXNzd29yZA==
+ local secret=my-cluster-secrets
+ local key=monitor
+ local value=dGVzdC1wYXNzd29yZA==
+ kubectl_bin patch secret my-cluster-secrets '-p={"data":{"monitor": "dGVzdC1wYXNzd29yZA=="}}'
++ mktemp
+ local LAST_OUT=/tmp/tmp.0ervZCt2x8
++ mktemp
+ local LAST_ERR=/tmp/tmp.GzuPyCBV6R
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl patch secret my-cluster-secrets '-p={"data":{"monitor": "dGVzdC1wYXNzd29yZA=="}}'
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.0ervZCt2x8
secret/my-cluster-secrets patched
+ cat /tmp/tmp.GzuPyCBV6R
+ rm /tmp/tmp.0ervZCt2x8 /tmp/tmp.GzuPyCBV6R
+ return 0
+ wait_for_password_propagation my-cluster-secrets monitor
+ local secret=my-cluster-secrets
+ local user=monitor
+ local max_retry=240
++ getSecretData my-cluster-secrets root
++ local secretName=my-cluster-secrets
++ local dataKey=root
++ kubectl_bin get secrets/my-cluster-secrets '--template={{.data.root}}'
++ base64 --decode
+++ mktemp
++ local LAST_OUT=/tmp/tmp.fIOC2fZMvb
+++ mktemp
++ local LAST_ERR=/tmp/tmp.75FM7CN4f3
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get secrets/my-cluster-secrets '--template={{.data.root}}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.fIOC2fZMvb
++ cat /tmp/tmp.75FM7CN4f3
++ rm /tmp/tmp.fIOC2fZMvb /tmp/tmp.75FM7CN4f3
++ return 0
+ local root_pass=test-password
+ [[ perconalab/percona-xtradb-cluster-operator:main-pxc8.0 =~ 5\.7 ]]
+ retry=0
+ is_password_updated monitor '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local username=monitor
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
+ run_mysql 'SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\''' '-h some-name-pxc -uroot -p'\''test-password'\'''
+ grep additional_password
+ local 'command=SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\'''
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.aY5OJMM7qQ
+++ mktemp
++ local LAST_ERR=/tmp/tmp.DQWv4TGWyX
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.aY5OJMM7qQ
++ cat /tmp/tmp.DQWv4TGWyX
++ rm /tmp/tmp.aY5OJMM7qQ /tmp/tmp.DQWv4TGWyX
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
{"additional_password": "*C1F414D9BAF378B656A849B31F9F8AF3125F558B"}
+ retry=0
+ is_old_password_discarded monitor '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local username=monitor
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
+ run_mysql 'SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\''' '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local 'command=SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\'''
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
+ grep NULL
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.D2kPIeQMQv
+++ mktemp
++ local LAST_ERR=/tmp/tmp.niBHbsWshy
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.D2kPIeQMQv
++ cat /tmp/tmp.niBHbsWshy
++ rm /tmp/tmp.D2kPIeQMQv /tmp/tmp.niBHbsWshy
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ egrep '^(pxc|proxysql)$'
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ echo 'waiting for password propagation'
waiting for password propagation
+ sleep 1
+ let retry+=1
+ [[ 1 -ge 240 ]]
+ is_old_password_discarded monitor '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local username=monitor
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
+ grep NULL
+ run_mysql 'SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\''' '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local 'command=SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\'''
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.I30wjE681c
+++ mktemp
++ local LAST_ERR=/tmp/tmp.406PQ7SfyK
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.I30wjE681c
++ cat /tmp/tmp.406PQ7SfyK
++ rm /tmp/tmp.I30wjE681c /tmp/tmp.406PQ7SfyK
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ egrep '^(pxc|proxysql)$'
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ echo 'waiting for password propagation'
waiting for password propagation
+ sleep 1
+ let retry+=1
+ [[ 2 -ge 240 ]]
+ is_old_password_discarded monitor '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local username=monitor
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
+ run_mysql 'SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\''' '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local 'command=SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\'''
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
+ grep NULL
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.18NSYyyGv5
+++ mktemp
++ local LAST_ERR=/tmp/tmp.L2k5HNCmvE
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.18NSYyyGv5
++ cat /tmp/tmp.L2k5HNCmvE
++ rm /tmp/tmp.18NSYyyGv5 /tmp/tmp.L2k5HNCmvE
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ echo 'waiting for password propagation'
waiting for password propagation
+ sleep 1
+ let retry+=1
+ [[ 3 -ge 240 ]]
+ is_old_password_discarded monitor '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local username=monitor
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
+ grep NULL
+ run_mysql 'SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\''' '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local 'command=SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\'''
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.XxYIwasTtD
+++ mktemp
++ local LAST_ERR=/tmp/tmp.8iVroru7ER
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.XxYIwasTtD
++ cat /tmp/tmp.8iVroru7ER
++ rm /tmp/tmp.XxYIwasTtD /tmp/tmp.8iVroru7ER
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ echo 'waiting for password propagation'
waiting for password propagation
+ sleep 1
+ let retry+=1
+ [[ 4 -ge 240 ]]
+ is_old_password_discarded monitor '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local username=monitor
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
+ run_mysql 'SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\''' '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local 'command=SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\'''
+ grep NULL
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.n2SzGwAGkR
+++ mktemp
++ local LAST_ERR=/tmp/tmp.dympUYGcTq
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.n2SzGwAGkR
++ cat /tmp/tmp.dympUYGcTq
++ rm /tmp/tmp.n2SzGwAGkR /tmp/tmp.dympUYGcTq
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ echo 'waiting for password propagation'
waiting for password propagation
+ sleep 1
+ let retry+=1
+ [[ 5 -ge 240 ]]
+ is_old_password_discarded monitor '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local username=monitor
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
+ run_mysql 'SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\''' '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local 'command=SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\'''
+ grep NULL
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.vqpNFOdcS1
+++ mktemp
++ local LAST_ERR=/tmp/tmp.cakKF0tb8W
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.vqpNFOdcS1
++ cat /tmp/tmp.cakKF0tb8W
++ rm /tmp/tmp.vqpNFOdcS1 /tmp/tmp.cakKF0tb8W
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ echo 'waiting for password propagation'
waiting for password propagation
+ sleep 1
+ let retry+=1
+ [[ 6 -ge 240 ]]
+ is_old_password_discarded monitor '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local username=monitor
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
+ run_mysql 'SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\''' '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local 'command=SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\'''
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
+ grep NULL
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.z9wn6SK5XQ
+++ mktemp
++ local LAST_ERR=/tmp/tmp.yDrSjJluzv
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.z9wn6SK5XQ
++ cat /tmp/tmp.yDrSjJluzv
++ rm /tmp/tmp.z9wn6SK5XQ /tmp/tmp.yDrSjJluzv
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ echo 'waiting for password propagation'
waiting for password propagation
+ sleep 1
+ let retry+=1
+ [[ 7 -ge 240 ]]
+ is_old_password_discarded monitor '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local username=monitor
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
+ run_mysql 'SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\''' '-h some-name-pxc -uroot -p'\''test-password'\'''
+ grep NULL
+ local 'command=SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\'''
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.qIWgZRtBOd
+++ mktemp
++ local LAST_ERR=/tmp/tmp.2eyC2FiRMd
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.qIWgZRtBOd
++ cat /tmp/tmp.2eyC2FiRMd
++ rm /tmp/tmp.qIWgZRtBOd /tmp/tmp.2eyC2FiRMd
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ echo 'waiting for password propagation'
waiting for password propagation
+ sleep 1
+ let retry+=1
+ [[ 8 -ge 240 ]]
+ is_old_password_discarded monitor '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local username=monitor
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
+ run_mysql 'SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\''' '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local 'command=SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\'''
+ grep NULL
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.uYQy6KjRO8
+++ mktemp
++ local LAST_ERR=/tmp/tmp.Lz1YnAXpOK
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.uYQy6KjRO8
++ cat /tmp/tmp.Lz1YnAXpOK
++ rm /tmp/tmp.uYQy6KjRO8 /tmp/tmp.Lz1YnAXpOK
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ echo 'waiting for password propagation'
waiting for password propagation
+ sleep 1
+ let retry+=1
+ [[ 9 -ge 240 ]]
+ is_old_password_discarded monitor '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local username=monitor
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
+ run_mysql 'SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\''' '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local 'command=SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\'''
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
+ grep NULL
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.jdP6Stp2Mo
+++ mktemp
++ local LAST_ERR=/tmp/tmp.Okdal3tIA6
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.jdP6Stp2Mo
++ cat /tmp/tmp.Okdal3tIA6
++ rm /tmp/tmp.jdP6Stp2Mo /tmp/tmp.Okdal3tIA6
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ echo 'waiting for password propagation'
waiting for password propagation
+ sleep 1
+ let retry+=1
+ [[ 10 -ge 240 ]]
+ is_old_password_discarded monitor '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local username=monitor
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
+ run_mysql 'SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\''' '-h some-name-pxc -uroot -p'\''test-password'\'''
+ grep NULL
+ local 'command=SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\'''
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.hihSNKNMS3
+++ mktemp
++ local LAST_ERR=/tmp/tmp.sDf1YJg1LQ
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.hihSNKNMS3
++ cat /tmp/tmp.sDf1YJg1LQ
++ rm /tmp/tmp.hihSNKNMS3 /tmp/tmp.sDf1YJg1LQ
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ echo 'waiting for password propagation'
waiting for password propagation
+ sleep 1
+ let retry+=1
+ [[ 11 -ge 240 ]]
+ is_old_password_discarded monitor '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local username=monitor
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
+ run_mysql 'SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\''' '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local 'command=SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\'''
+ grep NULL
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.b5GYJ8gCOQ
+++ mktemp
++ local LAST_ERR=/tmp/tmp.JiYH4mcQkv
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.b5GYJ8gCOQ
++ cat /tmp/tmp.JiYH4mcQkv
++ rm /tmp/tmp.b5GYJ8gCOQ /tmp/tmp.JiYH4mcQkv
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ echo 'waiting for password propagation'
waiting for password propagation
+ sleep 1
+ let retry+=1
+ [[ 12 -ge 240 ]]
+ is_old_password_discarded monitor '-h some-name-pxc -uroot -p'\''test-password'\'''
+ local username=monitor
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
+ run_mysql 'SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\''' '-h some-name-pxc -uroot -p'\''test-password'\'''
+ grep NULL
+ local 'command=SELECT User_attributes FROM mysql.user WHERE user='\''monitor'\'''
+ local 'uri=-h some-name-pxc -uroot -p'\''test-password'\'''
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.2ERq0PLDE2
+++ mktemp
++ local LAST_ERR=/tmp/tmp.AzIHnllzK8
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.2ERq0PLDE2
++ cat /tmp/tmp.AzIHnllzK8
++ rm /tmp/tmp.2ERq0PLDE2 /tmp/tmp.AzIHnllzK8
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
NULL
+ wait_cluster_consistency some-name 3 2
+ local cluster_name=some-name
+ local cluster_size=3
+ local proxy_size=2
+ '[' -z 2 ']'
+ desc 'wait cluster consistency'
+ set +o xtrace


-----------------------------------------------------------------------------------
wait cluster consistency
-----------------------------------------------------------------------------------

+ sleep 7
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.stpKEq5BKZ
+++ mktemp
++ local LAST_ERR=/tmp/tmp.1kpvfEUdNt
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.stpKEq5BKZ
++ cat /tmp/tmp.1kpvfEUdNt
++ rm /tmp/tmp.stpKEq5BKZ /tmp/tmp.1kpvfEUdNt
++ return 0
+ [[ ready == \r\e\a\d\y ]]
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.pxc.ready}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.p6DA3hvICx
+++ mktemp
++ local LAST_ERR=/tmp/tmp.h1PMOrbclQ
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.pxc.ready}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.p6DA3hvICx
++ cat /tmp/tmp.h1PMOrbclQ
++ rm /tmp/tmp.p6DA3hvICx /tmp/tmp.h1PMOrbclQ
++ return 0
+ [[ 3 == \3 ]]
+++ get_proxy_engine some-name
+++ local cluster_name=some-name
++++ get_proxy some-name
++++ local target_cluster=some-name
+++++ kubectl_bin get pxc some-name -o 'jsonpath={.spec.haproxy.enabled}'
++++++ mktemp
+++++ local LAST_OUT=/tmp/tmp.7cXBI4G1mN
++++++ mktemp
+++++ local LAST_ERR=/tmp/tmp.v5KpHRnson
+++++ local exit_status=0
++++++ seq 0 2
+++++ for i in '$(seq 0 2)'
+++++ set +e
+++++ kubectl get pxc some-name -o 'jsonpath={.spec.haproxy.enabled}'
+++++ exit_status=0
+++++ set -e
+++++ '[' 0 '!=' 0 ']'
+++++ break
+++++ cat /tmp/tmp.7cXBI4G1mN
+++++ cat /tmp/tmp.v5KpHRnson
+++++ rm /tmp/tmp.7cXBI4G1mN /tmp/tmp.v5KpHRnson
+++++ return 0
++++ [[ '' == \t\r\u\e ]]
+++++ kubectl_bin get pxc some-name -o 'jsonpath={.spec.proxysql.enabled}'
++++++ mktemp
+++++ local LAST_OUT=/tmp/tmp.oEXyUrNgfn
++++++ mktemp
+++++ local LAST_ERR=/tmp/tmp.Bh2YQXEN9E
+++++ local exit_status=0
++++++ seq 0 2
+++++ for i in '$(seq 0 2)'
+++++ set +e
+++++ kubectl get pxc some-name -o 'jsonpath={.spec.proxysql.enabled}'
+++++ exit_status=0
+++++ set -e
+++++ '[' 0 '!=' 0 ']'
+++++ break
+++++ cat /tmp/tmp.oEXyUrNgfn
+++++ cat /tmp/tmp.Bh2YQXEN9E
+++++ rm /tmp/tmp.oEXyUrNgfn /tmp/tmp.Bh2YQXEN9E
+++++ return 0
++++ [[ true == \t\r\u\e ]]
++++ echo some-name-proxysql
++++ return
+++ local cluster_proxy=some-name-proxysql
+++ echo proxysql
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.proxysql.ready}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.nnchBCVPyv
+++ mktemp
++ local LAST_ERR=/tmp/tmp.J7rsUVpDZI
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.proxysql.ready}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.nnchBCVPyv
++ cat /tmp/tmp.J7rsUVpDZI
++ rm /tmp/tmp.nnchBCVPyv /tmp/tmp.J7rsUVpDZI
++ return 0
+ [[ 2 == \2 ]]
+ sleep 10
+ compare_mysql_cmd select-4 'SHOW TABLES;' '-h some-name-proxysql -umonitor -p'\''test-password'\'''
+ local command_id=select-4
+ local 'command=SHOW TABLES;'
+ local 'uri=-h some-name-proxysql -umonitor -p'\''test-password'\'''
+ local postfix=
+ local expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4.sql
+ [[ perconalab/percona-xtradb-cluster-operator:main-pxc8.0 =~ 8\.0 ]]
+ '[' -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4-80.sql ']'
+ expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4-80.sql
+ run_mysql 'SHOW TABLES;' '-h some-name-proxysql -umonitor -p'\''test-password'\'''
+ local 'command=SHOW TABLES;'
+ local 'uri=-h some-name-proxysql -umonitor -p'\''test-password'\'''
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.FoyYvH8Rxr
+++ mktemp
++ local LAST_ERR=/tmp/tmp.imor4S4LCN
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.FoyYvH8Rxr
++ cat /tmp/tmp.imor4S4LCN
++ rm /tmp/tmp.FoyYvH8Rxr /tmp/tmp.imor4S4LCN
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ '[' '!' -s /tmp/tmp.HdChWhA5Fm/select-4.sql ']'
+ diff -u /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4-80.sql /tmp/tmp.HdChWhA5Fm/select-4.sql
+ desc 'test operator'
+ set +o xtrace


-----------------------------------------------------------------------------------
test operator
-----------------------------------------------------------------------------------

+ patch_secret my-cluster-secrets operator dGVzdC1wYXNzd29yZA==
+ local secret=my-cluster-secrets
+ local key=operator
+ local value=dGVzdC1wYXNzd29yZA==
+ kubectl_bin patch secret my-cluster-secrets '-p={"data":{"operator": "dGVzdC1wYXNzd29yZA=="}}'
++ mktemp
+ local LAST_OUT=/tmp/tmp.dWG40bgsM9
++ mktemp
+ local LAST_ERR=/tmp/tmp.zUTZ1pasA4
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl patch secret my-cluster-secrets '-p={"data":{"operator": "dGVzdC1wYXNzd29yZA=="}}'
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.dWG40bgsM9
secret/my-cluster-secrets patched
+ cat /tmp/tmp.zUTZ1pasA4
+ rm /tmp/tmp.dWG40bgsM9 /tmp/tmp.zUTZ1pasA4
+ return 0
+ sleep 15
+ wait_cluster_consistency some-name 3 2
+ local cluster_name=some-name
+ local cluster_size=3
+ local proxy_size=2
+ '[' -z 2 ']'
+ desc 'wait cluster consistency'
+ set +o xtrace


-----------------------------------------------------------------------------------
wait cluster consistency
-----------------------------------------------------------------------------------

+ sleep 7
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.gHC4gZwee2
+++ mktemp
++ local LAST_ERR=/tmp/tmp.dK9UeJ7qmB
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.gHC4gZwee2
++ cat /tmp/tmp.dK9UeJ7qmB
++ rm /tmp/tmp.gHC4gZwee2 /tmp/tmp.dK9UeJ7qmB
++ return 0
+ [[ initializing == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.syLZOel23g
+++ mktemp
++ local LAST_ERR=/tmp/tmp.kiObaThtsd
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.syLZOel23g
++ cat /tmp/tmp.kiObaThtsd
++ rm /tmp/tmp.syLZOel23g /tmp/tmp.kiObaThtsd
++ return 0
+ [[ ready == \r\e\a\d\y ]]
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.pxc.ready}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.xFA4jcDCHH
+++ mktemp
++ local LAST_ERR=/tmp/tmp.fzkjwgvx4S
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.pxc.ready}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.xFA4jcDCHH
++ cat /tmp/tmp.fzkjwgvx4S
++ rm /tmp/tmp.xFA4jcDCHH /tmp/tmp.fzkjwgvx4S
++ return 0
+ [[ 3 == \3 ]]
+++ get_proxy_engine some-name
+++ local cluster_name=some-name
++++ get_proxy some-name
++++ local target_cluster=some-name
+++++ kubectl_bin get pxc some-name -o 'jsonpath={.spec.haproxy.enabled}'
++++++ mktemp
+++++ local LAST_OUT=/tmp/tmp.xtpWwFM0C2
++++++ mktemp
+++++ local LAST_ERR=/tmp/tmp.rWhEA8GiI3
+++++ local exit_status=0
++++++ seq 0 2
+++++ for i in '$(seq 0 2)'
+++++ set +e
+++++ kubectl get pxc some-name -o 'jsonpath={.spec.haproxy.enabled}'
+++++ exit_status=0
+++++ set -e
+++++ '[' 0 '!=' 0 ']'
+++++ break
+++++ cat /tmp/tmp.xtpWwFM0C2
+++++ cat /tmp/tmp.rWhEA8GiI3
+++++ rm /tmp/tmp.xtpWwFM0C2 /tmp/tmp.rWhEA8GiI3
+++++ return 0
++++ [[ '' == \t\r\u\e ]]
+++++ kubectl_bin get pxc some-name -o 'jsonpath={.spec.proxysql.enabled}'
++++++ mktemp
+++++ local LAST_OUT=/tmp/tmp.VFyHh6E2Pe
++++++ mktemp
+++++ local LAST_ERR=/tmp/tmp.vwi2uX1sjS
+++++ local exit_status=0
++++++ seq 0 2
+++++ for i in '$(seq 0 2)'
+++++ set +e
+++++ kubectl get pxc some-name -o 'jsonpath={.spec.proxysql.enabled}'
+++++ exit_status=0
+++++ set -e
+++++ '[' 0 '!=' 0 ']'
+++++ break
+++++ cat /tmp/tmp.VFyHh6E2Pe
+++++ cat /tmp/tmp.vwi2uX1sjS
+++++ rm /tmp/tmp.VFyHh6E2Pe /tmp/tmp.vwi2uX1sjS
+++++ return 0
++++ [[ true == \t\r\u\e ]]
++++ echo some-name-proxysql
++++ return
+++ local cluster_proxy=some-name-proxysql
+++ echo proxysql
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.proxysql.ready}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.1wkudyEkwq
+++ mktemp
++ local LAST_ERR=/tmp/tmp.YCi2ndRPbo
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.proxysql.ready}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.1wkudyEkwq
++ cat /tmp/tmp.YCi2ndRPbo
++ rm /tmp/tmp.1wkudyEkwq /tmp/tmp.YCi2ndRPbo
++ return 0
+ [[ 2 == \2 ]]
+ sleep 10
+ compare_mysql_cmd select-4 'SHOW TABLES;' '-h some-name-proxysql -uoperator -p'\''test-password'\'''
+ local command_id=select-4
+ local 'command=SHOW TABLES;'
+ local 'uri=-h some-name-proxysql -uoperator -p'\''test-password'\'''
+ local postfix=
+ local expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4.sql
+ [[ perconalab/percona-xtradb-cluster-operator:main-pxc8.0 =~ 8\.0 ]]
+ '[' -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4-80.sql ']'
+ expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4-80.sql
+ run_mysql 'SHOW TABLES;' '-h some-name-proxysql -uoperator -p'\''test-password'\'''
+ local 'command=SHOW TABLES;'
+ local 'uri=-h some-name-proxysql -uoperator -p'\''test-password'\'''
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.uAqaUVUFWG
+++ mktemp
++ local LAST_ERR=/tmp/tmp.hDqWMtMBDq
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.uAqaUVUFWG
++ cat /tmp/tmp.hDqWMtMBDq
++ rm /tmp/tmp.uAqaUVUFWG /tmp/tmp.hDqWMtMBDq
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ '[' '!' -s /tmp/tmp.HdChWhA5Fm/select-4.sql ']'
+ diff -u /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4-80.sql /tmp/tmp.HdChWhA5Fm/select-4.sql
+ desc 'change secret name'
+ set +o xtrace


-----------------------------------------------------------------------------------
change secret name
-----------------------------------------------------------------------------------

+ kubectl_bin patch pxc some-name --type merge --patch '{"spec": {"secretsName":"my-cluster-secrets-2"}}'
++ mktemp
+ local LAST_OUT=/tmp/tmp.KBl3IoczNP
++ mktemp
+ local LAST_ERR=/tmp/tmp.8EFmN9lomO
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl patch pxc some-name --type merge --patch '{"spec": {"secretsName":"my-cluster-secrets-2"}}'
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.KBl3IoczNP
perconaxtradbcluster.pxc.percona.com/some-name patched
+ cat /tmp/tmp.8EFmN9lomO
+ rm /tmp/tmp.KBl3IoczNP /tmp/tmp.8EFmN9lomO
+ return 0
+ sleep 30
+ wait_cluster_consistency some-name 3 2
+ local cluster_name=some-name
+ local cluster_size=3
+ local proxy_size=2
+ '[' -z 2 ']'
+ desc 'wait cluster consistency'
+ set +o xtrace


-----------------------------------------------------------------------------------
wait cluster consistency
-----------------------------------------------------------------------------------

+ sleep 7
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.LSXl2wQnnx
+++ mktemp
++ local LAST_ERR=/tmp/tmp.apiHl7MzTd
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.LSXl2wQnnx
++ cat /tmp/tmp.apiHl7MzTd
++ rm /tmp/tmp.LSXl2wQnnx /tmp/tmp.apiHl7MzTd
++ return 0
+ [[ initializing == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.i3Gjc3ESoS
+++ mktemp
++ local LAST_ERR=/tmp/tmp.DavFAIf8Xx
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.i3Gjc3ESoS
++ cat /tmp/tmp.DavFAIf8Xx
++ rm /tmp/tmp.i3Gjc3ESoS /tmp/tmp.DavFAIf8Xx
++ return 0
+ [[ initializing == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.CaaS9Ythud
+++ mktemp
++ local LAST_ERR=/tmp/tmp.l7w6mKdTD0
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.CaaS9Ythud
++ cat /tmp/tmp.l7w6mKdTD0
++ rm /tmp/tmp.CaaS9Ythud /tmp/tmp.l7w6mKdTD0
++ return 0
+ [[ initializing == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.ag4QIleZUr
+++ mktemp
++ local LAST_ERR=/tmp/tmp.ZQVCFg3XlF
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.ag4QIleZUr
++ cat /tmp/tmp.ZQVCFg3XlF
++ rm /tmp/tmp.ag4QIleZUr /tmp/tmp.ZQVCFg3XlF
++ return 0
+ [[ initializing == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.K0gRF9wonG
+++ mktemp
++ local LAST_ERR=/tmp/tmp.O5bco65STd
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.K0gRF9wonG
++ cat /tmp/tmp.O5bco65STd
++ rm /tmp/tmp.K0gRF9wonG /tmp/tmp.O5bco65STd
++ return 0
+ [[ initializing == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.KtrjVrj54V
+++ mktemp
++ local LAST_ERR=/tmp/tmp.W01QQ5apQE
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.KtrjVrj54V
++ cat /tmp/tmp.W01QQ5apQE
++ rm /tmp/tmp.KtrjVrj54V /tmp/tmp.W01QQ5apQE
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.ddGCUYOBTs
+++ mktemp
++ local LAST_ERR=/tmp/tmp.imfhXq2pbD
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.ddGCUYOBTs
++ cat /tmp/tmp.imfhXq2pbD
++ rm /tmp/tmp.ddGCUYOBTs /tmp/tmp.imfhXq2pbD
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.KTxZ9BdiQI
+++ mktemp
++ local LAST_ERR=/tmp/tmp.bSXc2owGPi
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.KTxZ9BdiQI
++ cat /tmp/tmp.bSXc2owGPi
++ rm /tmp/tmp.KTxZ9BdiQI /tmp/tmp.bSXc2owGPi
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.kDpJ0HRHOt
+++ mktemp
++ local LAST_ERR=/tmp/tmp.ln7P1wxBqm
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.kDpJ0HRHOt
++ cat /tmp/tmp.ln7P1wxBqm
++ rm /tmp/tmp.kDpJ0HRHOt /tmp/tmp.ln7P1wxBqm
++ return 0
+ [[ ready == \r\e\a\d\y ]]
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.pxc.ready}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.9YnbzVWpcb
+++ mktemp
++ local LAST_ERR=/tmp/tmp.tR7R2hQUkU
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.pxc.ready}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.9YnbzVWpcb
++ cat /tmp/tmp.tR7R2hQUkU
++ rm /tmp/tmp.9YnbzVWpcb /tmp/tmp.tR7R2hQUkU
++ return 0
+ [[ 3 == \3 ]]
+++ get_proxy_engine some-name
+++ local cluster_name=some-name
++++ get_proxy some-name
++++ local target_cluster=some-name
+++++ kubectl_bin get pxc some-name -o 'jsonpath={.spec.haproxy.enabled}'
++++++ mktemp
+++++ local LAST_OUT=/tmp/tmp.LfIHCLG7Dt
++++++ mktemp
+++++ local LAST_ERR=/tmp/tmp.TvpOB2Kepd
+++++ local exit_status=0
++++++ seq 0 2
+++++ for i in '$(seq 0 2)'
+++++ set +e
+++++ kubectl get pxc some-name -o 'jsonpath={.spec.haproxy.enabled}'
+++++ exit_status=0
+++++ set -e
+++++ '[' 0 '!=' 0 ']'
+++++ break
+++++ cat /tmp/tmp.LfIHCLG7Dt
+++++ cat /tmp/tmp.TvpOB2Kepd
+++++ rm /tmp/tmp.LfIHCLG7Dt /tmp/tmp.TvpOB2Kepd
+++++ return 0
++++ [[ '' == \t\r\u\e ]]
+++++ kubectl_bin get pxc some-name -o 'jsonpath={.spec.proxysql.enabled}'
++++++ mktemp
+++++ local LAST_OUT=/tmp/tmp.GGoZIrxM2U
++++++ mktemp
+++++ local LAST_ERR=/tmp/tmp.vrkIbpYRFj
+++++ local exit_status=0
++++++ seq 0 2
+++++ for i in '$(seq 0 2)'
+++++ set +e
+++++ kubectl get pxc some-name -o 'jsonpath={.spec.proxysql.enabled}'
+++++ exit_status=0
+++++ set -e
+++++ '[' 0 '!=' 0 ']'
+++++ break
+++++ cat /tmp/tmp.GGoZIrxM2U
+++++ cat /tmp/tmp.vrkIbpYRFj
+++++ rm /tmp/tmp.GGoZIrxM2U /tmp/tmp.vrkIbpYRFj
+++++ return 0
++++ [[ true == \t\r\u\e ]]
++++ echo some-name-proxysql
++++ return
+++ local cluster_proxy=some-name-proxysql
+++ echo proxysql
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.proxysql.ready}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.UoqDcWy4sn
+++ mktemp
++ local LAST_ERR=/tmp/tmp.mWBVXVr9jI
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.proxysql.ready}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.UoqDcWy4sn
++ cat /tmp/tmp.mWBVXVr9jI
++ rm /tmp/tmp.UoqDcWy4sn /tmp/tmp.mWBVXVr9jI
++ return 0
+ [[ 2 == \2 ]]
+ desc 'test new operator'
+ set +o xtrace


-----------------------------------------------------------------------------------
test new operator
-----------------------------------------------------------------------------------

+ newpass=test-password2
++ base64
++ echo -n test-password2
+ newpassencrypted=dGVzdC1wYXNzd29yZDI=
+ patch_secret my-cluster-secrets-2 operator dGVzdC1wYXNzd29yZDI=
+ local secret=my-cluster-secrets-2
+ local key=operator
+ local value=dGVzdC1wYXNzd29yZDI=
+ kubectl_bin patch secret my-cluster-secrets-2 '-p={"data":{"operator": "dGVzdC1wYXNzd29yZDI="}}'
++ mktemp
+ local LAST_OUT=/tmp/tmp.hIIk4jSVCH
++ mktemp
+ local LAST_ERR=/tmp/tmp.RwMKlXP1NJ
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl patch secret my-cluster-secrets-2 '-p={"data":{"operator": "dGVzdC1wYXNzd29yZDI="}}'
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.hIIk4jSVCH
secret/my-cluster-secrets-2 patched
+ cat /tmp/tmp.RwMKlXP1NJ
+ rm /tmp/tmp.hIIk4jSVCH /tmp/tmp.RwMKlXP1NJ
+ return 0
+ sleep 15
+ wait_cluster_consistency some-name 3 2
+ local cluster_name=some-name
+ local cluster_size=3
+ local proxy_size=2
+ '[' -z 2 ']'
+ desc 'wait cluster consistency'
+ set +o xtrace


-----------------------------------------------------------------------------------
wait cluster consistency
-----------------------------------------------------------------------------------

+ sleep 7
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.NvCPfLUIdV
+++ mktemp
++ local LAST_ERR=/tmp/tmp.BMNtuz1otV
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.NvCPfLUIdV
++ cat /tmp/tmp.BMNtuz1otV
++ rm /tmp/tmp.NvCPfLUIdV /tmp/tmp.BMNtuz1otV
++ return 0
+ [[ initializing == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.eEoM7NjbLS
+++ mktemp
++ local LAST_ERR=/tmp/tmp.INzwmNjGNN
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.eEoM7NjbLS
++ cat /tmp/tmp.INzwmNjGNN
++ rm /tmp/tmp.eEoM7NjbLS /tmp/tmp.INzwmNjGNN
++ return 0
+ [[ ready == \r\e\a\d\y ]]
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.pxc.ready}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.UqUg4C9Ejq
+++ mktemp
++ local LAST_ERR=/tmp/tmp.9PsWiI6nvQ
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.pxc.ready}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.UqUg4C9Ejq
++ cat /tmp/tmp.9PsWiI6nvQ
++ rm /tmp/tmp.UqUg4C9Ejq /tmp/tmp.9PsWiI6nvQ
++ return 0
+ [[ 3 == \3 ]]
+++ get_proxy_engine some-name
+++ local cluster_name=some-name
++++ get_proxy some-name
++++ local target_cluster=some-name
+++++ kubectl_bin get pxc some-name -o 'jsonpath={.spec.haproxy.enabled}'
++++++ mktemp
+++++ local LAST_OUT=/tmp/tmp.QHIUAbHhQX
++++++ mktemp
+++++ local LAST_ERR=/tmp/tmp.J8QygezFS9
+++++ local exit_status=0
++++++ seq 0 2
+++++ for i in '$(seq 0 2)'
+++++ set +e
+++++ kubectl get pxc some-name -o 'jsonpath={.spec.haproxy.enabled}'
+++++ exit_status=0
+++++ set -e
+++++ '[' 0 '!=' 0 ']'
+++++ break
+++++ cat /tmp/tmp.QHIUAbHhQX
+++++ cat /tmp/tmp.J8QygezFS9
+++++ rm /tmp/tmp.QHIUAbHhQX /tmp/tmp.J8QygezFS9
+++++ return 0
++++ [[ '' == \t\r\u\e ]]
+++++ kubectl_bin get pxc some-name -o 'jsonpath={.spec.proxysql.enabled}'
++++++ mktemp
+++++ local LAST_OUT=/tmp/tmp.oQ6Zat7b47
++++++ mktemp
+++++ local LAST_ERR=/tmp/tmp.46Dd1s43yK
+++++ local exit_status=0
++++++ seq 0 2
+++++ for i in '$(seq 0 2)'
+++++ set +e
+++++ kubectl get pxc some-name -o 'jsonpath={.spec.proxysql.enabled}'
+++++ exit_status=0
+++++ set -e
+++++ '[' 0 '!=' 0 ']'
+++++ break
+++++ cat /tmp/tmp.oQ6Zat7b47
+++++ cat /tmp/tmp.46Dd1s43yK
+++++ rm /tmp/tmp.oQ6Zat7b47 /tmp/tmp.46Dd1s43yK
+++++ return 0
++++ [[ true == \t\r\u\e ]]
++++ echo some-name-proxysql
++++ return
+++ local cluster_proxy=some-name-proxysql
+++ echo proxysql
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.proxysql.ready}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.MDwNQY7CdH
+++ mktemp
++ local LAST_ERR=/tmp/tmp.7XJ096rvZk
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.proxysql.ready}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.MDwNQY7CdH
++ cat /tmp/tmp.7XJ096rvZk
++ rm /tmp/tmp.MDwNQY7CdH /tmp/tmp.7XJ096rvZk
++ return 0
+ [[ 2 == \2 ]]
+ sleep 20
+ compare_mysql_cmd select-4 'SHOW TABLES;' '-h some-name-proxysql -uoperator -p'\''test-password2'\'''
+ local command_id=select-4
+ local 'command=SHOW TABLES;'
+ local 'uri=-h some-name-proxysql -uoperator -p'\''test-password2'\'''
+ local postfix=
+ local expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4.sql
+ [[ perconalab/percona-xtradb-cluster-operator:main-pxc8.0 =~ 8\.0 ]]
+ '[' -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4-80.sql ']'
+ expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4-80.sql
+ run_mysql 'SHOW TABLES;' '-h some-name-proxysql -uoperator -p'\''test-password2'\'''
+ local 'command=SHOW TABLES;'
+ local 'uri=-h some-name-proxysql -uoperator -p'\''test-password2'\'''
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.AnQVImmtCv
+++ mktemp
++ local LAST_ERR=/tmp/tmp.ynUo1Jrml1
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.AnQVImmtCv
++ cat /tmp/tmp.ynUo1Jrml1
++ rm /tmp/tmp.AnQVImmtCv /tmp/tmp.ynUo1Jrml1
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ '[' '!' -s /tmp/tmp.HdChWhA5Fm/select-4.sql ']'
+ diff -u /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4-80.sql /tmp/tmp.HdChWhA5Fm/select-4.sql
++ getSecretData my-cluster-secrets-2 root
++ local secretName=my-cluster-secrets-2
++ local dataKey=root
++ kubectl_bin get secrets/my-cluster-secrets-2 '--template={{.data.root}}'
++ base64 --decode
+++ mktemp
++ local LAST_OUT=/tmp/tmp.NftaqH88ig
+++ mktemp
++ local LAST_ERR=/tmp/tmp.sFTQvrYjRI
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get secrets/my-cluster-secrets-2 '--template={{.data.root}}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.NftaqH88ig
++ cat /tmp/tmp.sFTQvrYjRI
++ rm /tmp/tmp.NftaqH88ig /tmp/tmp.sFTQvrYjRI
++ return 0
+ newpass='&,HB#dq@P8>e^FTGQqP'
+ desc 'test new users sync'
+ set +o xtrace


-----------------------------------------------------------------------------------
test new users sync
-----------------------------------------------------------------------------------

+ run_mysql 'CREATE USER '\''testsync'\''@'\''%'\'' IDENTIFIED BY '\''&,HB#dq@P8>e^FTGQqP'\'';' '-h some-name-pxc -uroot -p'\''&,HB#dq@P8>e^FTGQqP'\'''
+ local 'command=CREATE USER '\''testsync'\''@'\''%'\'' IDENTIFIED BY '\''&,HB#dq@P8>e^FTGQqP'\'';'
+ local 'uri=-h some-name-pxc -uroot -p'\''&,HB#dq@P8>e^FTGQqP'\'''
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.wgKiJ42OZT
+++ mktemp
++ local LAST_ERR=/tmp/tmp.dCvGiL5jHb
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.wgKiJ42OZT
++ cat /tmp/tmp.dCvGiL5jHb
++ rm /tmp/tmp.wgKiJ42OZT /tmp/tmp.dCvGiL5jHb
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ sleep 40
+ compare_mysql_cmd select-4 'SHOW TABLES;' '-h some-name-proxysql -utestsync -p'\''&,HB#dq@P8>e^FTGQqP'\'''
+ local command_id=select-4
+ local 'command=SHOW TABLES;'
+ local 'uri=-h some-name-proxysql -utestsync -p'\''&,HB#dq@P8>e^FTGQqP'\'''
+ local postfix=
+ local expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4.sql
+ [[ perconalab/percona-xtradb-cluster-operator:main-pxc8.0 =~ 8\.0 ]]
+ '[' -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4-80.sql ']'
+ expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4-80.sql
+ run_mysql 'SHOW TABLES;' '-h some-name-proxysql -utestsync -p'\''&,HB#dq@P8>e^FTGQqP'\'''
+ local 'command=SHOW TABLES;'
+ local 'uri=-h some-name-proxysql -utestsync -p'\''&,HB#dq@P8>e^FTGQqP'\'''
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.xZ4meA6ehP
+++ mktemp
++ local LAST_ERR=/tmp/tmp.dIcmv90seH
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.xZ4meA6ehP
++ cat /tmp/tmp.dIcmv90seH
++ rm /tmp/tmp.xZ4meA6ehP /tmp/tmp.dIcmv90seH
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ '[' '!' -s /tmp/tmp.HdChWhA5Fm/select-4.sql ']'
+ diff -u /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4-80.sql /tmp/tmp.HdChWhA5Fm/select-4.sql
++ getSecretData internal-some-name operator
++ local secretName=internal-some-name
++ local dataKey=operator
++ kubectl_bin get secrets/internal-some-name '--template={{.data.operator}}'
++ base64 --decode
+++ mktemp
++ local LAST_OUT=/tmp/tmp.WHjsNt9ukF
+++ mktemp
++ local LAST_ERR=/tmp/tmp.dL7jbZQ9e7
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get secrets/internal-some-name '--template={{.data.operator}}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.WHjsNt9ukF
++ cat /tmp/tmp.dL7jbZQ9e7
++ rm /tmp/tmp.WHjsNt9ukF /tmp/tmp.dL7jbZQ9e7
++ return 0
+ pass=test-password2
+ desc 'check secret without operator'
+ set +o xtrace


-----------------------------------------------------------------------------------
check secret without operator
-----------------------------------------------------------------------------------

+ kubectl_bin apply -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/conf/secrets.yml
++ mktemp
+ local LAST_OUT=/tmp/tmp.EwQ3MfWuk2
++ mktemp
+ local LAST_ERR=/tmp/tmp.0gYvYoFtvL
+ local exit_status=0
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl apply -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/conf/secrets.yml
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.EwQ3MfWuk2
secret/my-cluster-secrets-2 configured
+ cat /tmp/tmp.0gYvYoFtvL
Warning: resource secrets/my-cluster-secrets-2 is missing the kubectl.kubernetes.io/last-applied-configuration annotation which is required by kubectl apply. kubectl apply should only be used on resources created declaratively by either kubectl create --save-config or kubectl apply. The missing annotation will be patched automatically.
+ rm /tmp/tmp.EwQ3MfWuk2 /tmp/tmp.0gYvYoFtvL
+ return 0
+ sleep 15
+ compare_mysql_cmd select-4 'SHOW TABLES;' '-h some-name-proxysql -uoperator -p'\''test-password2'\'''
+ local command_id=select-4
+ local 'command=SHOW TABLES;'
+ local 'uri=-h some-name-proxysql -uoperator -p'\''test-password2'\'''
+ local postfix=
+ local expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4.sql
+ [[ perconalab/percona-xtradb-cluster-operator:main-pxc8.0 =~ 8\.0 ]]
+ '[' -f /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4-80.sql ']'
+ expected_result=/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4-80.sql
+ run_mysql 'SHOW TABLES;' '-h some-name-proxysql -uoperator -p'\''test-password2'\'''
+ local 'command=SHOW TABLES;'
+ local 'uri=-h some-name-proxysql -uoperator -p'\''test-password2'\'''
++ get_client_pod
++ kubectl_bin get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.nYgjHvDy3o
+++ mktemp
++ local LAST_ERR=/tmp/tmp.2QGveprNJX
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pods --selector=name=pxc-client -o 'jsonpath={.items[].metadata.name}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.nYgjHvDy3o
++ cat /tmp/tmp.2QGveprNJX
++ rm /tmp/tmp.nYgjHvDy3o /tmp/tmp.2QGveprNJX
++ return 0
+ client_pod=pxc-client-599db5b9bc-cfmgv
+ wait_pod pxc-client-599db5b9bc-cfmgv
+ local pod=pxc-client-599db5b9bc-cfmgv
+ local max_retry=480
+ local ns=
++ echo pxc-client-599db5b9bc-cfmgv
++ /usr/bin/sed -E 's/.*-(pxc|proxysql)-[0-9]/\1/'
++ egrep '^(pxc|proxysql)$'
+ local container=
+ set +o xtrace
pod/pxc-client-599db5b9bc-cfmgv condition met
pxc-client-599db5b9bc-cfmgv.Ok
+ set +o xtrace
+ '[' '!' -s /tmp/tmp.HdChWhA5Fm/select-4.sql ']'
+ diff -u /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/compare/select-4-80.sql /tmp/tmp.HdChWhA5Fm/select-4.sql
+ newpass=test-password2
++ echo -n test-password2
++ base64
+ newpassencrypted=dGVzdC1wYXNzd29yZDI=
+ apply_config /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/conf/some-name.yml
+ '[' -z '' ']'
+ cat_config /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/conf/some-name.yml
+ kubectl_bin apply -f -
+ cat /mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/conf/some-name.yml
+ /usr/bin/sed -e 's#apiVersion: pxc.percona.com/v.*$#apiVersion: pxc.percona.com/v1#'
++ mktemp
+ local LAST_OUT=/tmp/tmp.tBE5LjKdPu
+ /usr/bin/sed -e 's#image:.*-backup$#image: perconalab/percona-xtradb-cluster-operator:k8spxc-1313-8.0-backup#'
+ /usr/bin/sed -e 's#apply:.*#apply: Never#'
+ /usr/bin/sed -e 's#image:.*-proxysql$#image: perconalab/percona-xtradb-cluster-operator:main-proxysql#'
+ /usr/bin/sed -e 's#image:.*-logcollector$#image: perconalab/percona-xtradb-cluster-operator:main-logcollector#'
+ /usr/bin/sed -e 's#image:.*-haproxy$#image: perconalab/percona-xtradb-cluster-operator:main-haproxy#'
+ /usr/bin/sed -e s~minio-service.#namespace~minio-service.users-3908~
++ mktemp
+ /usr/bin/sed -e 's#image:.*-pmm$#image: perconalab/pmm-client:dev-latest#'
+ local LAST_ERR=/tmp/tmp.tJs5ZBcmm0
+ local exit_status=0
+ /usr/bin/sed -e 's#image:.*-pxc\([0-9]*.[0-9]*\)\{0,1\}$#image: perconalab/percona-xtradb-cluster-operator:main-pxc8.0#'
+ /usr/bin/sed -e 's#image:.*-init$#image: perconalab/percona-xtradb-cluster-operator:PR-1522-1ed4605b#'
++ seq 0 2
+ for i in '$(seq 0 2)'
+ set +e
+ kubectl apply -f -
+ /usr/bin/sed -e 's#image:.*\/percona-xtradb-cluster:.*$#image: perconalab/percona-xtradb-cluster-operator:main-pxc8.0#'
+ exit_status=0
+ set -e
+ '[' 0 '!=' 0 ']'
+ break
+ cat /tmp/tmp.tBE5LjKdPu
perconaxtradbcluster.pxc.percona.com/some-name configured
+ cat /tmp/tmp.tJs5ZBcmm0
+ rm /tmp/tmp.tBE5LjKdPu /tmp/tmp.tJs5ZBcmm0
+ return 0
+ sleep 15
+ wait_cluster_consistency some-name 3 3
+ local cluster_name=some-name
+ local cluster_size=3
+ local proxy_size=3
+ '[' -z 3 ']'
+ desc 'wait cluster consistency'
+ set +o xtrace


-----------------------------------------------------------------------------------
wait cluster consistency
-----------------------------------------------------------------------------------

+ sleep 7
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.0Yyhaz2x3W
+++ mktemp
++ local LAST_ERR=/tmp/tmp.GVLevJyxmV
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.0Yyhaz2x3W
++ cat /tmp/tmp.GVLevJyxmV
++ rm /tmp/tmp.0Yyhaz2x3W /tmp/tmp.GVLevJyxmV
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.FlzajYuiu0
+++ mktemp
++ local LAST_ERR=/tmp/tmp.dWXvcVzK1l
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.FlzajYuiu0
++ cat /tmp/tmp.dWXvcVzK1l
++ rm /tmp/tmp.FlzajYuiu0 /tmp/tmp.dWXvcVzK1l
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.XAa9JvgNe5
+++ mktemp
++ local LAST_ERR=/tmp/tmp.1W06fzSyOf
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.XAa9JvgNe5
++ cat /tmp/tmp.1W06fzSyOf
++ rm /tmp/tmp.XAa9JvgNe5 /tmp/tmp.1W06fzSyOf
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.uLmKU5iz7r
+++ mktemp
++ local LAST_ERR=/tmp/tmp.j3S6gCYNSV
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.uLmKU5iz7r
++ cat /tmp/tmp.j3S6gCYNSV
++ rm /tmp/tmp.uLmKU5iz7r /tmp/tmp.j3S6gCYNSV
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.r5raHDQzJE
+++ mktemp
++ local LAST_ERR=/tmp/tmp.cFF7RbMAua
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.r5raHDQzJE
++ cat /tmp/tmp.cFF7RbMAua
++ rm /tmp/tmp.r5raHDQzJE /tmp/tmp.cFF7RbMAua
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.wmzTlOxLh6
+++ mktemp
++ local LAST_ERR=/tmp/tmp.UHmSKPWYbs
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.wmzTlOxLh6
++ cat /tmp/tmp.UHmSKPWYbs
++ rm /tmp/tmp.wmzTlOxLh6 /tmp/tmp.UHmSKPWYbs
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.mTQxveA7A6
+++ mktemp
++ local LAST_ERR=/tmp/tmp.msEKqC1EO6
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.mTQxveA7A6
++ cat /tmp/tmp.msEKqC1EO6
++ rm /tmp/tmp.mTQxveA7A6 /tmp/tmp.msEKqC1EO6
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.Zfq20GemB4
+++ mktemp
++ local LAST_ERR=/tmp/tmp.jTcN1jXGwg
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.Zfq20GemB4
++ cat /tmp/tmp.jTcN1jXGwg
++ rm /tmp/tmp.Zfq20GemB4 /tmp/tmp.jTcN1jXGwg
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.UihFbkYPFy
+++ mktemp
++ local LAST_ERR=/tmp/tmp.jgeVrMeMwH
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.UihFbkYPFy
++ cat /tmp/tmp.jgeVrMeMwH
++ rm /tmp/tmp.UihFbkYPFy /tmp/tmp.jgeVrMeMwH
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.5RpFBGN0QO
+++ mktemp
++ local LAST_ERR=/tmp/tmp.rA9N9ueGmr
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.5RpFBGN0QO
++ cat /tmp/tmp.rA9N9ueGmr
++ rm /tmp/tmp.5RpFBGN0QO /tmp/tmp.rA9N9ueGmr
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.N984VbzuqM
+++ mktemp
++ local LAST_ERR=/tmp/tmp.emHEYhRx09
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.N984VbzuqM
++ cat /tmp/tmp.emHEYhRx09
++ rm /tmp/tmp.N984VbzuqM /tmp/tmp.emHEYhRx09
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.z1ynv31RXJ
+++ mktemp
++ local LAST_ERR=/tmp/tmp.b5NdZkqzwH
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.z1ynv31RXJ
++ cat /tmp/tmp.b5NdZkqzwH
++ rm /tmp/tmp.z1ynv31RXJ /tmp/tmp.b5NdZkqzwH
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.U1qpT4SKkw
+++ mktemp
++ local LAST_ERR=/tmp/tmp.bTJyzofIWp
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.U1qpT4SKkw
++ cat /tmp/tmp.bTJyzofIWp
++ rm /tmp/tmp.U1qpT4SKkw /tmp/tmp.bTJyzofIWp
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.XVNrsh30Fq
+++ mktemp
++ local LAST_ERR=/tmp/tmp.ziaJawkZF0
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.XVNrsh30Fq
++ cat /tmp/tmp.ziaJawkZF0
++ rm /tmp/tmp.XVNrsh30Fq /tmp/tmp.ziaJawkZF0
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.GLvBRVC7K5
+++ mktemp
++ local LAST_ERR=/tmp/tmp.nOeFrorlvX
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.GLvBRVC7K5
++ cat /tmp/tmp.nOeFrorlvX
++ rm /tmp/tmp.GLvBRVC7K5 /tmp/tmp.nOeFrorlvX
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.GO9RoqLwsm
+++ mktemp
++ local LAST_ERR=/tmp/tmp.ZX0Rhx3H8I
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.GO9RoqLwsm
++ cat /tmp/tmp.ZX0Rhx3H8I
++ rm /tmp/tmp.GO9RoqLwsm /tmp/tmp.ZX0Rhx3H8I
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.d5Qv0Eiao4
+++ mktemp
++ local LAST_ERR=/tmp/tmp.OTgJhSCqFR
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.d5Qv0Eiao4
++ cat /tmp/tmp.OTgJhSCqFR
++ rm /tmp/tmp.d5Qv0Eiao4 /tmp/tmp.OTgJhSCqFR
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.fZGovbxJn1
+++ mktemp
++ local LAST_ERR=/tmp/tmp.ILxW85ewSw
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.fZGovbxJn1
++ cat /tmp/tmp.ILxW85ewSw
++ rm /tmp/tmp.fZGovbxJn1 /tmp/tmp.ILxW85ewSw
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.aOBlDLhzVS
+++ mktemp
++ local LAST_ERR=/tmp/tmp.KI8rTOriqF
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.aOBlDLhzVS
++ cat /tmp/tmp.KI8rTOriqF
++ rm /tmp/tmp.aOBlDLhzVS /tmp/tmp.KI8rTOriqF
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.j2TQ0lhSXV
+++ mktemp
++ local LAST_ERR=/tmp/tmp.spjXK4ubyy
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.j2TQ0lhSXV
++ cat /tmp/tmp.spjXK4ubyy
++ rm /tmp/tmp.j2TQ0lhSXV /tmp/tmp.spjXK4ubyy
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.tAgFFQVxn5
+++ mktemp
++ local LAST_ERR=/tmp/tmp.pBKsuT9Coo
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.tAgFFQVxn5
++ cat /tmp/tmp.pBKsuT9Coo
++ rm /tmp/tmp.tAgFFQVxn5 /tmp/tmp.pBKsuT9Coo
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.GMO1d3KaOR
+++ mktemp
++ local LAST_ERR=/tmp/tmp.bhFS0lgh3l
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.GMO1d3KaOR
++ cat /tmp/tmp.bhFS0lgh3l
++ rm /tmp/tmp.GMO1d3KaOR /tmp/tmp.bhFS0lgh3l
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.gluSRf1VM1
+++ mktemp
++ local LAST_ERR=/tmp/tmp.16CrH5wk7Q
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.gluSRf1VM1
++ cat /tmp/tmp.16CrH5wk7Q
++ rm /tmp/tmp.gluSRf1VM1 /tmp/tmp.16CrH5wk7Q
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.cZHHda2f0Q
+++ mktemp
++ local LAST_ERR=/tmp/tmp.G43RF0oW9j
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.cZHHda2f0Q
++ cat /tmp/tmp.G43RF0oW9j
++ rm /tmp/tmp.cZHHda2f0Q /tmp/tmp.G43RF0oW9j
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.CwQjgDDQ3C
+++ mktemp
++ local LAST_ERR=/tmp/tmp.GJM0bjulZQ
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.CwQjgDDQ3C
++ cat /tmp/tmp.GJM0bjulZQ
++ rm /tmp/tmp.CwQjgDDQ3C /tmp/tmp.GJM0bjulZQ
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.lfYSB0omnn
+++ mktemp
++ local LAST_ERR=/tmp/tmp.G4zqkovT3J
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.lfYSB0omnn
++ cat /tmp/tmp.G4zqkovT3J
++ rm /tmp/tmp.lfYSB0omnn /tmp/tmp.G4zqkovT3J
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.M700RU7dKS
+++ mktemp
++ local LAST_ERR=/tmp/tmp.zf7rHOHyZO
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.M700RU7dKS
++ cat /tmp/tmp.zf7rHOHyZO
++ rm /tmp/tmp.M700RU7dKS /tmp/tmp.zf7rHOHyZO
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.cCcFUANLOA
+++ mktemp
++ local LAST_ERR=/tmp/tmp.YcoEWdPFZv
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.cCcFUANLOA
++ cat /tmp/tmp.YcoEWdPFZv
++ rm /tmp/tmp.cCcFUANLOA /tmp/tmp.YcoEWdPFZv
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.KvjkULqcTG
+++ mktemp
++ local LAST_ERR=/tmp/tmp.h8jcp15Erz
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.KvjkULqcTG
++ cat /tmp/tmp.h8jcp15Erz
++ rm /tmp/tmp.KvjkULqcTG /tmp/tmp.h8jcp15Erz
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.iVGUu4L220
+++ mktemp
++ local LAST_ERR=/tmp/tmp.Uzc4d4Fxx4
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.iVGUu4L220
++ cat /tmp/tmp.Uzc4d4Fxx4
++ rm /tmp/tmp.iVGUu4L220 /tmp/tmp.Uzc4d4Fxx4
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.hArRR9M2Jl
+++ mktemp
++ local LAST_ERR=/tmp/tmp.7yBu6DqVLx
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.hArRR9M2Jl
++ cat /tmp/tmp.7yBu6DqVLx
++ rm /tmp/tmp.hArRR9M2Jl /tmp/tmp.7yBu6DqVLx
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.lUtn81HXht
+++ mktemp
++ local LAST_ERR=/tmp/tmp.5y6W94eOw5
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.lUtn81HXht
++ cat /tmp/tmp.5y6W94eOw5
++ rm /tmp/tmp.lUtn81HXht /tmp/tmp.5y6W94eOw5
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.Q3qTePdnks
+++ mktemp
++ local LAST_ERR=/tmp/tmp.2wtkq9RLtZ
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.Q3qTePdnks
++ cat /tmp/tmp.2wtkq9RLtZ
++ rm /tmp/tmp.Q3qTePdnks /tmp/tmp.2wtkq9RLtZ
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.tAlo8TcHUc
+++ mktemp
++ local LAST_ERR=/tmp/tmp.hikv9b0Rcx
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.tAlo8TcHUc
++ cat /tmp/tmp.hikv9b0Rcx
++ rm /tmp/tmp.tAlo8TcHUc /tmp/tmp.hikv9b0Rcx
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.9ucXoYUbCC
+++ mktemp
++ local LAST_ERR=/tmp/tmp.LtLweljJ4v
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.9ucXoYUbCC
++ cat /tmp/tmp.LtLweljJ4v
++ rm /tmp/tmp.9ucXoYUbCC /tmp/tmp.LtLweljJ4v
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.cmhrPOMCge
+++ mktemp
++ local LAST_ERR=/tmp/tmp.IAzGpQSC5v
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.cmhrPOMCge
++ cat /tmp/tmp.IAzGpQSC5v
++ rm /tmp/tmp.cmhrPOMCge /tmp/tmp.IAzGpQSC5v
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.yM6kHq2u8q
+++ mktemp
++ local LAST_ERR=/tmp/tmp.CPDdPKvBh1
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.yM6kHq2u8q
++ cat /tmp/tmp.CPDdPKvBh1
++ rm /tmp/tmp.yM6kHq2u8q /tmp/tmp.CPDdPKvBh1
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.zPMh1uhfym
+++ mktemp
++ local LAST_ERR=/tmp/tmp.FzXGsdr6WT
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.zPMh1uhfym
++ cat /tmp/tmp.FzXGsdr6WT
++ rm /tmp/tmp.zPMh1uhfym /tmp/tmp.FzXGsdr6WT
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.4PRm893Mkt
+++ mktemp
++ local LAST_ERR=/tmp/tmp.ftFBFO0Lk6
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.4PRm893Mkt
++ cat /tmp/tmp.ftFBFO0Lk6
++ rm /tmp/tmp.4PRm893Mkt /tmp/tmp.ftFBFO0Lk6
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.Bu4JklrQr1
+++ mktemp
++ local LAST_ERR=/tmp/tmp.S8LYc5EklW
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.Bu4JklrQr1
++ cat /tmp/tmp.S8LYc5EklW
++ rm /tmp/tmp.Bu4JklrQr1 /tmp/tmp.S8LYc5EklW
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.54vTgla7JT
+++ mktemp
++ local LAST_ERR=/tmp/tmp.AIP7KFTATc
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.54vTgla7JT
++ cat /tmp/tmp.AIP7KFTATc
++ rm /tmp/tmp.54vTgla7JT /tmp/tmp.AIP7KFTATc
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.mJdKVAIDMu
+++ mktemp
++ local LAST_ERR=/tmp/tmp.8ukeVvnPA3
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.mJdKVAIDMu
++ cat /tmp/tmp.8ukeVvnPA3
++ rm /tmp/tmp.mJdKVAIDMu /tmp/tmp.8ukeVvnPA3
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.5n56VjD7W0
+++ mktemp
++ local LAST_ERR=/tmp/tmp.0SAlirYMPU
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.5n56VjD7W0
++ cat /tmp/tmp.0SAlirYMPU
++ rm /tmp/tmp.5n56VjD7W0 /tmp/tmp.0SAlirYMPU
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.MIxigeKtrn
+++ mktemp
++ local LAST_ERR=/tmp/tmp.Jhd7XVaHFQ
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.MIxigeKtrn
++ cat /tmp/tmp.Jhd7XVaHFQ
++ rm /tmp/tmp.MIxigeKtrn /tmp/tmp.Jhd7XVaHFQ
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.7QPfp8srwu
+++ mktemp
++ local LAST_ERR=/tmp/tmp.qld3qBXz5d
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.7QPfp8srwu
++ cat /tmp/tmp.qld3qBXz5d
++ rm /tmp/tmp.7QPfp8srwu /tmp/tmp.qld3qBXz5d
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.kt8uwGXYW5
+++ mktemp
++ local LAST_ERR=/tmp/tmp.evO3isHtud
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.kt8uwGXYW5
++ cat /tmp/tmp.evO3isHtud
++ rm /tmp/tmp.kt8uwGXYW5 /tmp/tmp.evO3isHtud
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.19uy26D6po
+++ mktemp
++ local LAST_ERR=/tmp/tmp.2SiqByc0Er
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.19uy26D6po
++ cat /tmp/tmp.2SiqByc0Er
++ rm /tmp/tmp.19uy26D6po /tmp/tmp.2SiqByc0Er
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.7y484jEatU
+++ mktemp
++ local LAST_ERR=/tmp/tmp.DDVxC7azso
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.7y484jEatU
++ cat /tmp/tmp.DDVxC7azso
++ rm /tmp/tmp.7y484jEatU /tmp/tmp.DDVxC7azso
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.uRkZLcUCfo
+++ mktemp
++ local LAST_ERR=/tmp/tmp.JjUVtfuK2m
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.uRkZLcUCfo
++ cat /tmp/tmp.JjUVtfuK2m
++ rm /tmp/tmp.uRkZLcUCfo /tmp/tmp.JjUVtfuK2m
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.mdkE57QgGk
+++ mktemp
++ local LAST_ERR=/tmp/tmp.pBO2JRXoEc
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.mdkE57QgGk
++ cat /tmp/tmp.pBO2JRXoEc
++ rm /tmp/tmp.mdkE57QgGk /tmp/tmp.pBO2JRXoEc
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.XZEGc9X4KM
+++ mktemp
++ local LAST_ERR=/tmp/tmp.hLr3sDPRwB
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.XZEGc9X4KM
++ cat /tmp/tmp.hLr3sDPRwB
++ rm /tmp/tmp.XZEGc9X4KM /tmp/tmp.hLr3sDPRwB
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.zGbxGSKjX5
+++ mktemp
++ local LAST_ERR=/tmp/tmp.mGiQCdk1ep
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.zGbxGSKjX5
++ cat /tmp/tmp.mGiQCdk1ep
++ rm /tmp/tmp.zGbxGSKjX5 /tmp/tmp.mGiQCdk1ep
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.4RViQWTYeZ
+++ mktemp
++ local LAST_ERR=/tmp/tmp.qK0W1rxlIZ
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.4RViQWTYeZ
++ cat /tmp/tmp.qK0W1rxlIZ
++ rm /tmp/tmp.4RViQWTYeZ /tmp/tmp.qK0W1rxlIZ
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.1Rjnbk70v5
+++ mktemp
++ local LAST_ERR=/tmp/tmp.pUeWnaKTVr
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.1Rjnbk70v5
++ cat /tmp/tmp.pUeWnaKTVr
++ rm /tmp/tmp.1Rjnbk70v5 /tmp/tmp.pUeWnaKTVr
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.UWIGhFjJzC
+++ mktemp
++ local LAST_ERR=/tmp/tmp.j7agntUF1e
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.UWIGhFjJzC
++ cat /tmp/tmp.j7agntUF1e
++ rm /tmp/tmp.UWIGhFjJzC /tmp/tmp.j7agntUF1e
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.LZd5kqt1LI
+++ mktemp
++ local LAST_ERR=/tmp/tmp.BbUVasFIqV
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.LZd5kqt1LI
++ cat /tmp/tmp.BbUVasFIqV
++ rm /tmp/tmp.LZd5kqt1LI /tmp/tmp.BbUVasFIqV
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.oN0hy9iY9F
+++ mktemp
++ local LAST_ERR=/tmp/tmp.HhaqZZO6lu
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.oN0hy9iY9F
++ cat /tmp/tmp.HhaqZZO6lu
++ rm /tmp/tmp.oN0hy9iY9F /tmp/tmp.HhaqZZO6lu
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.Jr2pVTAL0G
+++ mktemp
++ local LAST_ERR=/tmp/tmp.tEgdfEzXi6
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.Jr2pVTAL0G
++ cat /tmp/tmp.tEgdfEzXi6
++ rm /tmp/tmp.Jr2pVTAL0G /tmp/tmp.tEgdfEzXi6
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.SxJBfVsXlY
+++ mktemp
++ local LAST_ERR=/tmp/tmp.myOduk6H4I
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.SxJBfVsXlY
++ cat /tmp/tmp.myOduk6H4I
++ rm /tmp/tmp.SxJBfVsXlY /tmp/tmp.myOduk6H4I
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.YrE0s5wFfW
+++ mktemp
++ local LAST_ERR=/tmp/tmp.nv7mxuqc36
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.YrE0s5wFfW
++ cat /tmp/tmp.nv7mxuqc36
++ rm /tmp/tmp.YrE0s5wFfW /tmp/tmp.nv7mxuqc36
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.6qzANGBK37
+++ mktemp
++ local LAST_ERR=/tmp/tmp.Tibx1ReOvx
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.6qzANGBK37
++ cat /tmp/tmp.Tibx1ReOvx
++ rm /tmp/tmp.6qzANGBK37 /tmp/tmp.Tibx1ReOvx
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.vAgPGdw0tK
+++ mktemp
++ local LAST_ERR=/tmp/tmp.Z2p9MQJgiz
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.vAgPGdw0tK
++ cat /tmp/tmp.Z2p9MQJgiz
++ rm /tmp/tmp.vAgPGdw0tK /tmp/tmp.Z2p9MQJgiz
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.wNX7Ywraff
+++ mktemp
++ local LAST_ERR=/tmp/tmp.2TbdetIjZP
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.wNX7Ywraff
++ cat /tmp/tmp.2TbdetIjZP
++ rm /tmp/tmp.wNX7Ywraff /tmp/tmp.2TbdetIjZP
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.DbhZktfTt0
+++ mktemp
++ local LAST_ERR=/tmp/tmp.X1jbfKbIhk
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.DbhZktfTt0
++ cat /tmp/tmp.X1jbfKbIhk
++ rm /tmp/tmp.DbhZktfTt0 /tmp/tmp.X1jbfKbIhk
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.652nTECdEQ
+++ mktemp
++ local LAST_ERR=/tmp/tmp.zQ9nG4fQaK
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.652nTECdEQ
++ cat /tmp/tmp.zQ9nG4fQaK
++ rm /tmp/tmp.652nTECdEQ /tmp/tmp.zQ9nG4fQaK
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.rnDQNTIyAK
+++ mktemp
++ local LAST_ERR=/tmp/tmp.VwhxbwAgt8
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.rnDQNTIyAK
++ cat /tmp/tmp.VwhxbwAgt8
++ rm /tmp/tmp.rnDQNTIyAK /tmp/tmp.VwhxbwAgt8
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.qr7RfHxsjP
+++ mktemp
++ local LAST_ERR=/tmp/tmp.pmuFmJhuvI
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.qr7RfHxsjP
++ cat /tmp/tmp.pmuFmJhuvI
++ rm /tmp/tmp.qr7RfHxsjP /tmp/tmp.pmuFmJhuvI
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.e7hFexeLaL
+++ mktemp
++ local LAST_ERR=/tmp/tmp.4cNvSeMWSP
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.e7hFexeLaL
++ cat /tmp/tmp.4cNvSeMWSP
++ rm /tmp/tmp.e7hFexeLaL /tmp/tmp.4cNvSeMWSP
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.kWHTA8GQz9
+++ mktemp
++ local LAST_ERR=/tmp/tmp.8JxVGULnwG
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.kWHTA8GQz9
++ cat /tmp/tmp.8JxVGULnwG
++ rm /tmp/tmp.kWHTA8GQz9 /tmp/tmp.8JxVGULnwG
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.8QwshVuKat
+++ mktemp
++ local LAST_ERR=/tmp/tmp.eN36vSjgpN
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.8QwshVuKat
++ cat /tmp/tmp.eN36vSjgpN
++ rm /tmp/tmp.8QwshVuKat /tmp/tmp.eN36vSjgpN
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.2uzXCrPsUR
+++ mktemp
++ local LAST_ERR=/tmp/tmp.JLNtbg0HiH
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.2uzXCrPsUR
++ cat /tmp/tmp.JLNtbg0HiH
++ rm /tmp/tmp.2uzXCrPsUR /tmp/tmp.JLNtbg0HiH
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.RZyVOZ8SJS
+++ mktemp
++ local LAST_ERR=/tmp/tmp.lBCuDnjmpu
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.RZyVOZ8SJS
++ cat /tmp/tmp.lBCuDnjmpu
++ rm /tmp/tmp.RZyVOZ8SJS /tmp/tmp.lBCuDnjmpu
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.krrMsaKQrb
+++ mktemp
++ local LAST_ERR=/tmp/tmp.A5nVb3hTng
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.krrMsaKQrb
++ cat /tmp/tmp.A5nVb3hTng
++ rm /tmp/tmp.krrMsaKQrb /tmp/tmp.A5nVb3hTng
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.fdEjVF2Ciz
+++ mktemp
++ local LAST_ERR=/tmp/tmp.0XxYZXORmu
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.fdEjVF2Ciz
++ cat /tmp/tmp.0XxYZXORmu
++ rm /tmp/tmp.fdEjVF2Ciz /tmp/tmp.0XxYZXORmu
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.wmq3uaITjY
+++ mktemp
++ local LAST_ERR=/tmp/tmp.Im4RUF0kN6
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.wmq3uaITjY
++ cat /tmp/tmp.Im4RUF0kN6
++ rm /tmp/tmp.wmq3uaITjY /tmp/tmp.Im4RUF0kN6
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.3hlu4s5f4F
+++ mktemp
++ local LAST_ERR=/tmp/tmp.DfHQeXSsgZ
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.3hlu4s5f4F
++ cat /tmp/tmp.DfHQeXSsgZ
++ rm /tmp/tmp.3hlu4s5f4F /tmp/tmp.DfHQeXSsgZ
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.gZMZ1SCZ3A
+++ mktemp
++ local LAST_ERR=/tmp/tmp.XGG4fV3Bbq
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.gZMZ1SCZ3A
++ cat /tmp/tmp.XGG4fV3Bbq
++ rm /tmp/tmp.gZMZ1SCZ3A /tmp/tmp.XGG4fV3Bbq
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.FGlut1Y99u
+++ mktemp
++ local LAST_ERR=/tmp/tmp.q7VqTcNauG
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.FGlut1Y99u
++ cat /tmp/tmp.q7VqTcNauG
++ rm /tmp/tmp.FGlut1Y99u /tmp/tmp.q7VqTcNauG
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.C4gVdMFoQ3
+++ mktemp
++ local LAST_ERR=/tmp/tmp.iFRgc3nA6U
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.C4gVdMFoQ3
++ cat /tmp/tmp.iFRgc3nA6U
++ rm /tmp/tmp.C4gVdMFoQ3 /tmp/tmp.iFRgc3nA6U
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.R260z0zZZL
+++ mktemp
++ local LAST_ERR=/tmp/tmp.EmZf64iF4x
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.R260z0zZZL
++ cat /tmp/tmp.EmZf64iF4x
++ rm /tmp/tmp.R260z0zZZL /tmp/tmp.EmZf64iF4x
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.EeiBAwojwV
+++ mktemp
++ local LAST_ERR=/tmp/tmp.oQZgwlUkAY
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.EeiBAwojwV
++ cat /tmp/tmp.oQZgwlUkAY
++ rm /tmp/tmp.EeiBAwojwV /tmp/tmp.oQZgwlUkAY
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.LQU6qZ7PHN
+++ mktemp
++ local LAST_ERR=/tmp/tmp.t315mO5UHu
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.LQU6qZ7PHN
++ cat /tmp/tmp.t315mO5UHu
++ rm /tmp/tmp.LQU6qZ7PHN /tmp/tmp.t315mO5UHu
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.a0utaHhVz0
+++ mktemp
++ local LAST_ERR=/tmp/tmp.jvrexBnkLw
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.a0utaHhVz0
++ cat /tmp/tmp.jvrexBnkLw
++ rm /tmp/tmp.a0utaHhVz0 /tmp/tmp.jvrexBnkLw
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.InDOp8eNxZ
+++ mktemp
++ local LAST_ERR=/tmp/tmp.Qdv7s5aOf6
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.InDOp8eNxZ
++ cat /tmp/tmp.Qdv7s5aOf6
++ rm /tmp/tmp.InDOp8eNxZ /tmp/tmp.Qdv7s5aOf6
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.b7nF6CWZTR
+++ mktemp
++ local LAST_ERR=/tmp/tmp.O0EmUXwTqu
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.b7nF6CWZTR
++ cat /tmp/tmp.O0EmUXwTqu
++ rm /tmp/tmp.b7nF6CWZTR /tmp/tmp.O0EmUXwTqu
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.SsoKioXctx
+++ mktemp
++ local LAST_ERR=/tmp/tmp.Ih1XOveBuy
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.SsoKioXctx
++ cat /tmp/tmp.Ih1XOveBuy
++ rm /tmp/tmp.SsoKioXctx /tmp/tmp.Ih1XOveBuy
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.3S8E8Lfi4V
+++ mktemp
++ local LAST_ERR=/tmp/tmp.JgeS7QxGYl
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.3S8E8Lfi4V
++ cat /tmp/tmp.JgeS7QxGYl
++ rm /tmp/tmp.3S8E8Lfi4V /tmp/tmp.JgeS7QxGYl
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.f2UpIIHsrC
+++ mktemp
++ local LAST_ERR=/tmp/tmp.TmAfsmShhb
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.f2UpIIHsrC
++ cat /tmp/tmp.TmAfsmShhb
++ rm /tmp/tmp.f2UpIIHsrC /tmp/tmp.TmAfsmShhb
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.ysCnBvgbf6
+++ mktemp
++ local LAST_ERR=/tmp/tmp.SGagrIDHei
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.ysCnBvgbf6
++ cat /tmp/tmp.SGagrIDHei
++ rm /tmp/tmp.ysCnBvgbf6 /tmp/tmp.SGagrIDHei
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.UdywkR5URv
+++ mktemp
++ local LAST_ERR=/tmp/tmp.8IZoeGk11g
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.UdywkR5URv
++ cat /tmp/tmp.8IZoeGk11g
++ rm /tmp/tmp.UdywkR5URv /tmp/tmp.8IZoeGk11g
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.kbWGltlu0k
+++ mktemp
++ local LAST_ERR=/tmp/tmp.8rlDdIdDhp
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.kbWGltlu0k
++ cat /tmp/tmp.8rlDdIdDhp
++ rm /tmp/tmp.kbWGltlu0k /tmp/tmp.8rlDdIdDhp
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.zqGZXnp3X8
+++ mktemp
++ local LAST_ERR=/tmp/tmp.XUVZGLVQiC
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.zqGZXnp3X8
++ cat /tmp/tmp.XUVZGLVQiC
++ rm /tmp/tmp.zqGZXnp3X8 /tmp/tmp.XUVZGLVQiC
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.25enSvwWfA
+++ mktemp
++ local LAST_ERR=/tmp/tmp.PwS56vuNkM
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.25enSvwWfA
++ cat /tmp/tmp.PwS56vuNkM
++ rm /tmp/tmp.25enSvwWfA /tmp/tmp.PwS56vuNkM
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.7d499xOSNt
+++ mktemp
++ local LAST_ERR=/tmp/tmp.Mcd53TkcTz
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.7d499xOSNt
++ cat /tmp/tmp.Mcd53TkcTz
++ rm /tmp/tmp.7d499xOSNt /tmp/tmp.Mcd53TkcTz
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.q6ByEUDpU7
+++ mktemp
++ local LAST_ERR=/tmp/tmp.I5CKbtGiIg
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.q6ByEUDpU7
++ cat /tmp/tmp.I5CKbtGiIg
++ rm /tmp/tmp.q6ByEUDpU7 /tmp/tmp.I5CKbtGiIg
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.7Mq2p1fegb
+++ mktemp
++ local LAST_ERR=/tmp/tmp.ru5Mp68RFH
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.7Mq2p1fegb
++ cat /tmp/tmp.ru5Mp68RFH
++ rm /tmp/tmp.7Mq2p1fegb /tmp/tmp.ru5Mp68RFH
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.I1lPKszGeC
+++ mktemp
++ local LAST_ERR=/tmp/tmp.F1awuvPhT9
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.I1lPKszGeC
++ cat /tmp/tmp.F1awuvPhT9
++ rm /tmp/tmp.I1lPKszGeC /tmp/tmp.F1awuvPhT9
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.zANqTabjJd
+++ mktemp
++ local LAST_ERR=/tmp/tmp.v5IbtKbhpY
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.zANqTabjJd
++ cat /tmp/tmp.v5IbtKbhpY
++ rm /tmp/tmp.zANqTabjJd /tmp/tmp.v5IbtKbhpY
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.eD72cysqKO
+++ mktemp
++ local LAST_ERR=/tmp/tmp.WkS0cQ19Kx
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.eD72cysqKO
++ cat /tmp/tmp.WkS0cQ19Kx
++ rm /tmp/tmp.eD72cysqKO /tmp/tmp.WkS0cQ19Kx
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.Cp3zjiXTy1
+++ mktemp
++ local LAST_ERR=/tmp/tmp.eKoQQdtUA4
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.Cp3zjiXTy1
++ cat /tmp/tmp.eKoQQdtUA4
++ rm /tmp/tmp.Cp3zjiXTy1 /tmp/tmp.eKoQQdtUA4
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.bC1TInZ0sg
+++ mktemp
++ local LAST_ERR=/tmp/tmp.bDwjJ58N6i
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.bC1TInZ0sg
++ cat /tmp/tmp.bDwjJ58N6i
++ rm /tmp/tmp.bC1TInZ0sg /tmp/tmp.bDwjJ58N6i
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.z8zjbMKcFa
+++ mktemp
++ local LAST_ERR=/tmp/tmp.AEH3Kl5XDF
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.z8zjbMKcFa
++ cat /tmp/tmp.AEH3Kl5XDF
++ rm /tmp/tmp.z8zjbMKcFa /tmp/tmp.AEH3Kl5XDF
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.roJENoOD5L
+++ mktemp
++ local LAST_ERR=/tmp/tmp.dl0OZ72Wdn
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.roJENoOD5L
++ cat /tmp/tmp.dl0OZ72Wdn
++ rm /tmp/tmp.roJENoOD5L /tmp/tmp.dl0OZ72Wdn
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.ZrOuAJXSMX
+++ mktemp
++ local LAST_ERR=/tmp/tmp.ryGgq4U0Px
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.ZrOuAJXSMX
++ cat /tmp/tmp.ryGgq4U0Px
++ rm /tmp/tmp.ZrOuAJXSMX /tmp/tmp.ryGgq4U0Px
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.cWwaLbWNOz
+++ mktemp
++ local LAST_ERR=/tmp/tmp.FR4OXHOsKk
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.cWwaLbWNOz
++ cat /tmp/tmp.FR4OXHOsKk
++ rm /tmp/tmp.cWwaLbWNOz /tmp/tmp.FR4OXHOsKk
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.ZT2npqPjyh
+++ mktemp
++ local LAST_ERR=/tmp/tmp.cmPZWRYpk6
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.ZT2npqPjyh
++ cat /tmp/tmp.cmPZWRYpk6
++ rm /tmp/tmp.ZT2npqPjyh /tmp/tmp.cmPZWRYpk6
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.zEGm3xEVfn
+++ mktemp
++ local LAST_ERR=/tmp/tmp.3QDjdlLZUl
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.zEGm3xEVfn
++ cat /tmp/tmp.3QDjdlLZUl
++ rm /tmp/tmp.zEGm3xEVfn /tmp/tmp.3QDjdlLZUl
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.kA69UlacFJ
+++ mktemp
++ local LAST_ERR=/tmp/tmp.cFessqbRNj
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.kA69UlacFJ
++ cat /tmp/tmp.cFessqbRNj
++ rm /tmp/tmp.kA69UlacFJ /tmp/tmp.cFessqbRNj
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.laWSZWbX8x
+++ mktemp
++ local LAST_ERR=/tmp/tmp.y2RJG5t7ut
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.laWSZWbX8x
++ cat /tmp/tmp.y2RJG5t7ut
++ rm /tmp/tmp.laWSZWbX8x /tmp/tmp.y2RJG5t7ut
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.VXuiUNrdmy
+++ mktemp
++ local LAST_ERR=/tmp/tmp.97V6vIfQ4x
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.VXuiUNrdmy
++ cat /tmp/tmp.97V6vIfQ4x
++ rm /tmp/tmp.VXuiUNrdmy /tmp/tmp.97V6vIfQ4x
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.lp2CZJKiuK
+++ mktemp
++ local LAST_ERR=/tmp/tmp.UQ1tLgBhgX
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.lp2CZJKiuK
++ cat /tmp/tmp.UQ1tLgBhgX
++ rm /tmp/tmp.lp2CZJKiuK /tmp/tmp.UQ1tLgBhgX
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.2dRDLRKhWk
+++ mktemp
++ local LAST_ERR=/tmp/tmp.MZ6pPD64v1
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.2dRDLRKhWk
++ cat /tmp/tmp.MZ6pPD64v1
++ rm /tmp/tmp.2dRDLRKhWk /tmp/tmp.MZ6pPD64v1
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.CueMcXgDiD
+++ mktemp
++ local LAST_ERR=/tmp/tmp.Zndgdl1Z09
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.CueMcXgDiD
++ cat /tmp/tmp.Zndgdl1Z09
++ rm /tmp/tmp.CueMcXgDiD /tmp/tmp.Zndgdl1Z09
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.4IVXeNf4rg
+++ mktemp
++ local LAST_ERR=/tmp/tmp.nEPe1cvTQ8
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.4IVXeNf4rg
++ cat /tmp/tmp.nEPe1cvTQ8
++ rm /tmp/tmp.4IVXeNf4rg /tmp/tmp.nEPe1cvTQ8
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.pdTwmJihm6
+++ mktemp
++ local LAST_ERR=/tmp/tmp.O2LfWy4mHR
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.pdTwmJihm6
++ cat /tmp/tmp.O2LfWy4mHR
++ rm /tmp/tmp.pdTwmJihm6 /tmp/tmp.O2LfWy4mHR
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.cwY7tZa2GZ
+++ mktemp
++ local LAST_ERR=/tmp/tmp.7SrrZDAwJh
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.cwY7tZa2GZ
++ cat /tmp/tmp.7SrrZDAwJh
++ rm /tmp/tmp.cwY7tZa2GZ /tmp/tmp.7SrrZDAwJh
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.1MyifjET3A
+++ mktemp
++ local LAST_ERR=/tmp/tmp.gDrwdJ1Gpb
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.1MyifjET3A
++ cat /tmp/tmp.gDrwdJ1Gpb
++ rm /tmp/tmp.1MyifjET3A /tmp/tmp.gDrwdJ1Gpb
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.VXLjs2iHKV
+++ mktemp
++ local LAST_ERR=/tmp/tmp.o5MQPxQ98c
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.VXLjs2iHKV
++ cat /tmp/tmp.o5MQPxQ98c
++ rm /tmp/tmp.VXLjs2iHKV /tmp/tmp.o5MQPxQ98c
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.gp1g7Tw0FE
+++ mktemp
++ local LAST_ERR=/tmp/tmp.Ampi455Peo
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.gp1g7Tw0FE
++ cat /tmp/tmp.Ampi455Peo
++ rm /tmp/tmp.gp1g7Tw0FE /tmp/tmp.Ampi455Peo
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.YOAkl9HWDS
+++ mktemp
++ local LAST_ERR=/tmp/tmp.ir4S3eaR9T
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.YOAkl9HWDS
++ cat /tmp/tmp.ir4S3eaR9T
++ rm /tmp/tmp.YOAkl9HWDS /tmp/tmp.ir4S3eaR9T
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.itPoypuV7z
+++ mktemp
++ local LAST_ERR=/tmp/tmp.2uwW5IHH4c
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.itPoypuV7z
++ cat /tmp/tmp.2uwW5IHH4c
++ rm /tmp/tmp.itPoypuV7z /tmp/tmp.2uwW5IHH4c
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.jNMV09ZUNI
+++ mktemp
++ local LAST_ERR=/tmp/tmp.BlWpT2F7QR
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.jNMV09ZUNI
++ cat /tmp/tmp.BlWpT2F7QR
++ rm /tmp/tmp.jNMV09ZUNI /tmp/tmp.BlWpT2F7QR
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.GF1YVfw9qZ
+++ mktemp
++ local LAST_ERR=/tmp/tmp.9PtLNx31pL
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.GF1YVfw9qZ
++ cat /tmp/tmp.9PtLNx31pL
++ rm /tmp/tmp.GF1YVfw9qZ /tmp/tmp.9PtLNx31pL
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.vMrAnlZNKB
+++ mktemp
++ local LAST_ERR=/tmp/tmp.LoYCBCJShF
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.vMrAnlZNKB
++ cat /tmp/tmp.LoYCBCJShF
++ rm /tmp/tmp.vMrAnlZNKB /tmp/tmp.LoYCBCJShF
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.WvpBuluNhY
+++ mktemp
++ local LAST_ERR=/tmp/tmp.ThvFyqcvGR
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.WvpBuluNhY
++ cat /tmp/tmp.ThvFyqcvGR
++ rm /tmp/tmp.WvpBuluNhY /tmp/tmp.ThvFyqcvGR
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.lyM63LeWhV
+++ mktemp
++ local LAST_ERR=/tmp/tmp.podhuM3EZf
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.lyM63LeWhV
++ cat /tmp/tmp.podhuM3EZf
++ rm /tmp/tmp.lyM63LeWhV /tmp/tmp.podhuM3EZf
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.ciGySTdH1V
+++ mktemp
++ local LAST_ERR=/tmp/tmp.XpBDHZ6Dkv
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.ciGySTdH1V
++ cat /tmp/tmp.XpBDHZ6Dkv
++ rm /tmp/tmp.ciGySTdH1V /tmp/tmp.XpBDHZ6Dkv
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.J8QcQHabNB
+++ mktemp
++ local LAST_ERR=/tmp/tmp.JB8XIVpBvu
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.J8QcQHabNB
++ cat /tmp/tmp.JB8XIVpBvu
++ rm /tmp/tmp.J8QcQHabNB /tmp/tmp.JB8XIVpBvu
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.9vaVJvOHTj
+++ mktemp
++ local LAST_ERR=/tmp/tmp.zzAghuuafE
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.9vaVJvOHTj
++ cat /tmp/tmp.zzAghuuafE
++ rm /tmp/tmp.9vaVJvOHTj /tmp/tmp.zzAghuuafE
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.LbtVDNFLwS
+++ mktemp
++ local LAST_ERR=/tmp/tmp.a7M61u3qzx
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.LbtVDNFLwS
++ cat /tmp/tmp.a7M61u3qzx
++ rm /tmp/tmp.LbtVDNFLwS /tmp/tmp.a7M61u3qzx
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.zilV6uZqWI
+++ mktemp
++ local LAST_ERR=/tmp/tmp.HPvxGAGbld
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.zilV6uZqWI
++ cat /tmp/tmp.HPvxGAGbld
++ rm /tmp/tmp.zilV6uZqWI /tmp/tmp.HPvxGAGbld
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.7wNH0AdBNR
+++ mktemp
++ local LAST_ERR=/tmp/tmp.GbA5uPxQLc
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.7wNH0AdBNR
++ cat /tmp/tmp.GbA5uPxQLc
++ rm /tmp/tmp.7wNH0AdBNR /tmp/tmp.GbA5uPxQLc
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.HzIFTsGDi7
+++ mktemp
++ local LAST_ERR=/tmp/tmp.WdX4RqkOwO
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.HzIFTsGDi7
++ cat /tmp/tmp.WdX4RqkOwO
++ rm /tmp/tmp.HzIFTsGDi7 /tmp/tmp.WdX4RqkOwO
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.7WwZ4gLDRS
+++ mktemp
++ local LAST_ERR=/tmp/tmp.hVM2NVjGkA
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.7WwZ4gLDRS
++ cat /tmp/tmp.hVM2NVjGkA
++ rm /tmp/tmp.7WwZ4gLDRS /tmp/tmp.hVM2NVjGkA
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.DpFRngH0KJ
+++ mktemp
++ local LAST_ERR=/tmp/tmp.5ihzis82F9
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.DpFRngH0KJ
++ cat /tmp/tmp.5ihzis82F9
++ rm /tmp/tmp.DpFRngH0KJ /tmp/tmp.5ihzis82F9
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.3TeBDNSFQR
+++ mktemp
++ local LAST_ERR=/tmp/tmp.bvEW2lfu7y
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.3TeBDNSFQR
++ cat /tmp/tmp.bvEW2lfu7y
++ rm /tmp/tmp.3TeBDNSFQR /tmp/tmp.bvEW2lfu7y
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.6EKhkdlYlX
+++ mktemp
++ local LAST_ERR=/tmp/tmp.PaatOFzdMW
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.6EKhkdlYlX
++ cat /tmp/tmp.PaatOFzdMW
++ rm /tmp/tmp.6EKhkdlYlX /tmp/tmp.PaatOFzdMW
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.HYcqP12oY7
+++ mktemp
++ local LAST_ERR=/tmp/tmp.z78JqnDsuy
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.HYcqP12oY7
++ cat /tmp/tmp.z78JqnDsuy
++ rm /tmp/tmp.HYcqP12oY7 /tmp/tmp.z78JqnDsuy
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.4Rnl3y7v1v
+++ mktemp
++ local LAST_ERR=/tmp/tmp.oryAqoHUmN
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.4Rnl3y7v1v
++ cat /tmp/tmp.oryAqoHUmN
++ rm /tmp/tmp.4Rnl3y7v1v /tmp/tmp.oryAqoHUmN
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.4lad6hBm6g
+++ mktemp
++ local LAST_ERR=/tmp/tmp.JbrbGySbjX
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.4lad6hBm6g
++ cat /tmp/tmp.JbrbGySbjX
++ rm /tmp/tmp.4lad6hBm6g /tmp/tmp.JbrbGySbjX
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.F4r2pYzjby
+++ mktemp
++ local LAST_ERR=/tmp/tmp.lWcoE4va2a
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.F4r2pYzjby
++ cat /tmp/tmp.lWcoE4va2a
++ rm /tmp/tmp.F4r2pYzjby /tmp/tmp.lWcoE4va2a
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.kYWPCIOuiI
+++ mktemp
++ local LAST_ERR=/tmp/tmp.wb64yn1nzK
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.kYWPCIOuiI
++ cat /tmp/tmp.wb64yn1nzK
++ rm /tmp/tmp.kYWPCIOuiI /tmp/tmp.wb64yn1nzK
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.QLds8voffE
+++ mktemp
++ local LAST_ERR=/tmp/tmp.pona8eqD47
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.QLds8voffE
++ cat /tmp/tmp.pona8eqD47
++ rm /tmp/tmp.QLds8voffE /tmp/tmp.pona8eqD47
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.uqGXnXJK1L
+++ mktemp
++ local LAST_ERR=/tmp/tmp.alkNYAm8lk
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.uqGXnXJK1L
++ cat /tmp/tmp.alkNYAm8lk
++ rm /tmp/tmp.uqGXnXJK1L /tmp/tmp.alkNYAm8lk
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.DGzQBOUfBx
+++ mktemp
++ local LAST_ERR=/tmp/tmp.YsSiNK9N70
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.DGzQBOUfBx
++ cat /tmp/tmp.YsSiNK9N70
++ rm /tmp/tmp.DGzQBOUfBx /tmp/tmp.YsSiNK9N70
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.AM0YT9JN4q
+++ mktemp
++ local LAST_ERR=/tmp/tmp.ozr8o0zOgH
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.AM0YT9JN4q
++ cat /tmp/tmp.ozr8o0zOgH
++ rm /tmp/tmp.AM0YT9JN4q /tmp/tmp.ozr8o0zOgH
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.8spw6tp7Y5
+++ mktemp
++ local LAST_ERR=/tmp/tmp.JjoHu16WLW
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.8spw6tp7Y5
++ cat /tmp/tmp.JjoHu16WLW
++ rm /tmp/tmp.8spw6tp7Y5 /tmp/tmp.JjoHu16WLW
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.yXTxhufROv
+++ mktemp
++ local LAST_ERR=/tmp/tmp.HeVP62ju9I
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.yXTxhufROv
++ cat /tmp/tmp.HeVP62ju9I
++ rm /tmp/tmp.yXTxhufROv /tmp/tmp.HeVP62ju9I
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.0POSSmYYtW
+++ mktemp
++ local LAST_ERR=/tmp/tmp.63QRGcUtu6
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.0POSSmYYtW
++ cat /tmp/tmp.63QRGcUtu6
++ rm /tmp/tmp.0POSSmYYtW /tmp/tmp.63QRGcUtu6
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.qGpGm6Hu1b
+++ mktemp
++ local LAST_ERR=/tmp/tmp.3rtI5P4Jma
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.qGpGm6Hu1b
++ cat /tmp/tmp.3rtI5P4Jma
++ rm /tmp/tmp.qGpGm6Hu1b /tmp/tmp.3rtI5P4Jma
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.AzN1ZnoWBO
+++ mktemp
++ local LAST_ERR=/tmp/tmp.fddVRLB5xv
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.AzN1ZnoWBO
++ cat /tmp/tmp.fddVRLB5xv
++ rm /tmp/tmp.AzN1ZnoWBO /tmp/tmp.fddVRLB5xv
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.Hy2xvna74o
+++ mktemp
++ local LAST_ERR=/tmp/tmp.WfoxSnGgxp
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.Hy2xvna74o
++ cat /tmp/tmp.WfoxSnGgxp
++ rm /tmp/tmp.Hy2xvna74o /tmp/tmp.WfoxSnGgxp
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.Br9gGuMz72
+++ mktemp
++ local LAST_ERR=/tmp/tmp.bmL2yJSxHE
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.Br9gGuMz72
++ cat /tmp/tmp.bmL2yJSxHE
++ rm /tmp/tmp.Br9gGuMz72 /tmp/tmp.bmL2yJSxHE
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.atdDKbjXUg
+++ mktemp
++ local LAST_ERR=/tmp/tmp.WkYOTpZyJI
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.atdDKbjXUg
++ cat /tmp/tmp.WkYOTpZyJI
++ rm /tmp/tmp.atdDKbjXUg /tmp/tmp.WkYOTpZyJI
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.UX01O0UjWi
+++ mktemp
++ local LAST_ERR=/tmp/tmp.ETrV4ocP76
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.UX01O0UjWi
++ cat /tmp/tmp.ETrV4ocP76
++ rm /tmp/tmp.UX01O0UjWi /tmp/tmp.ETrV4ocP76
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.ZODFrf2T2n
+++ mktemp
++ local LAST_ERR=/tmp/tmp.co24KRkJ5E
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.ZODFrf2T2n
++ cat /tmp/tmp.co24KRkJ5E
++ rm /tmp/tmp.ZODFrf2T2n /tmp/tmp.co24KRkJ5E
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.6cZnlOSqDN
+++ mktemp
++ local LAST_ERR=/tmp/tmp.dk4FVRMpuf
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.6cZnlOSqDN
++ cat /tmp/tmp.dk4FVRMpuf
++ rm /tmp/tmp.6cZnlOSqDN /tmp/tmp.dk4FVRMpuf
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.otHhCPjokv
+++ mktemp
++ local LAST_ERR=/tmp/tmp.pFSPZbVWnz
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.otHhCPjokv
++ cat /tmp/tmp.pFSPZbVWnz
++ rm /tmp/tmp.otHhCPjokv /tmp/tmp.pFSPZbVWnz
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.kJ8ZpSMYXX
+++ mktemp
++ local LAST_ERR=/tmp/tmp.1TfXdExV2A
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.kJ8ZpSMYXX
++ cat /tmp/tmp.1TfXdExV2A
++ rm /tmp/tmp.kJ8ZpSMYXX /tmp/tmp.1TfXdExV2A
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.jQ5M9ArTZA
+++ mktemp
++ local LAST_ERR=/tmp/tmp.Y397W9Taei
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.jQ5M9ArTZA
++ cat /tmp/tmp.Y397W9Taei
++ rm /tmp/tmp.jQ5M9ArTZA /tmp/tmp.Y397W9Taei
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.CQZM87A8WL
+++ mktemp
++ local LAST_ERR=/tmp/tmp.hTU2klAwio
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.CQZM87A8WL
++ cat /tmp/tmp.hTU2klAwio
++ rm /tmp/tmp.CQZM87A8WL /tmp/tmp.hTU2klAwio
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.lSZqhP4nYP
+++ mktemp
++ local LAST_ERR=/tmp/tmp.k2l57qurlG
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.lSZqhP4nYP
++ cat /tmp/tmp.k2l57qurlG
++ rm /tmp/tmp.lSZqhP4nYP /tmp/tmp.k2l57qurlG
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.Gs158nvPz9
+++ mktemp
++ local LAST_ERR=/tmp/tmp.pBQdSyDfDi
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.Gs158nvPz9
++ cat /tmp/tmp.pBQdSyDfDi
++ rm /tmp/tmp.Gs158nvPz9 /tmp/tmp.pBQdSyDfDi
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.KfI6Th9ate
+++ mktemp
++ local LAST_ERR=/tmp/tmp.slCZ4UZT2u
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.KfI6Th9ate
++ cat /tmp/tmp.slCZ4UZT2u
++ rm /tmp/tmp.KfI6Th9ate /tmp/tmp.slCZ4UZT2u
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.67FN1XcsTR
+++ mktemp
++ local LAST_ERR=/tmp/tmp.ExRTn8vbtF
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.67FN1XcsTR
++ cat /tmp/tmp.ExRTn8vbtF
++ rm /tmp/tmp.67FN1XcsTR /tmp/tmp.ExRTn8vbtF
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.pGuKIycnNb
+++ mktemp
++ local LAST_ERR=/tmp/tmp.ISG1T7qgpn
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.pGuKIycnNb
++ cat /tmp/tmp.ISG1T7qgpn
++ rm /tmp/tmp.pGuKIycnNb /tmp/tmp.ISG1T7qgpn
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.NQoS7Fxs4J
+++ mktemp
++ local LAST_ERR=/tmp/tmp.csEZRTaVZT
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.NQoS7Fxs4J
++ cat /tmp/tmp.csEZRTaVZT
++ rm /tmp/tmp.NQoS7Fxs4J /tmp/tmp.csEZRTaVZT
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.aPABF1TYQp
+++ mktemp
++ local LAST_ERR=/tmp/tmp.cksGLDIRkA
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.aPABF1TYQp
++ cat /tmp/tmp.cksGLDIRkA
++ rm /tmp/tmp.aPABF1TYQp /tmp/tmp.cksGLDIRkA
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.GmhyJ3K9nc
+++ mktemp
++ local LAST_ERR=/tmp/tmp.il2pwwNmeo
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.GmhyJ3K9nc
++ cat /tmp/tmp.il2pwwNmeo
++ rm /tmp/tmp.GmhyJ3K9nc /tmp/tmp.il2pwwNmeo
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.BCJLQ1lJwX
+++ mktemp
++ local LAST_ERR=/tmp/tmp.rGi7KCT8fQ
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.BCJLQ1lJwX
++ cat /tmp/tmp.rGi7KCT8fQ
++ rm /tmp/tmp.BCJLQ1lJwX /tmp/tmp.rGi7KCT8fQ
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.NvmJnsdhel
+++ mktemp
++ local LAST_ERR=/tmp/tmp.Gv1jOt3TOp
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.NvmJnsdhel
++ cat /tmp/tmp.Gv1jOt3TOp
++ rm /tmp/tmp.NvmJnsdhel /tmp/tmp.Gv1jOt3TOp
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.V5phbM9jVh
+++ mktemp
++ local LAST_ERR=/tmp/tmp.ZJHDxnJ6V7
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.V5phbM9jVh
++ cat /tmp/tmp.ZJHDxnJ6V7
++ rm /tmp/tmp.V5phbM9jVh /tmp/tmp.ZJHDxnJ6V7
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.B2A59YaVAC
+++ mktemp
++ local LAST_ERR=/tmp/tmp.CaYCjk65po
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.B2A59YaVAC
++ cat /tmp/tmp.CaYCjk65po
++ rm /tmp/tmp.B2A59YaVAC /tmp/tmp.CaYCjk65po
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.NVIRCMoTrK
+++ mktemp
++ local LAST_ERR=/tmp/tmp.YBPIvhvzZK
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.NVIRCMoTrK
++ cat /tmp/tmp.YBPIvhvzZK
++ rm /tmp/tmp.NVIRCMoTrK /tmp/tmp.YBPIvhvzZK
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.q1NBgm7uKR
+++ mktemp
++ local LAST_ERR=/tmp/tmp.1EEujRRbWz
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.q1NBgm7uKR
++ cat /tmp/tmp.1EEujRRbWz
++ rm /tmp/tmp.q1NBgm7uKR /tmp/tmp.1EEujRRbWz
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.effo3BgCvs
+++ mktemp
++ local LAST_ERR=/tmp/tmp.T9p3wfV9J6
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.effo3BgCvs
++ cat /tmp/tmp.T9p3wfV9J6
++ rm /tmp/tmp.effo3BgCvs /tmp/tmp.T9p3wfV9J6
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.DLmFDJwY54
+++ mktemp
++ local LAST_ERR=/tmp/tmp.tCoEWIyyWT
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.DLmFDJwY54
++ cat /tmp/tmp.tCoEWIyyWT
++ rm /tmp/tmp.DLmFDJwY54 /tmp/tmp.tCoEWIyyWT
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.JXuuwhSnhI
+++ mktemp
++ local LAST_ERR=/tmp/tmp.ZFgao6Q2Rb
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.JXuuwhSnhI
++ cat /tmp/tmp.ZFgao6Q2Rb
++ rm /tmp/tmp.JXuuwhSnhI /tmp/tmp.ZFgao6Q2Rb
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.kaOA4UZeuI
+++ mktemp
++ local LAST_ERR=/tmp/tmp.Om8lNHA2jF
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.kaOA4UZeuI
++ cat /tmp/tmp.Om8lNHA2jF
++ rm /tmp/tmp.kaOA4UZeuI /tmp/tmp.Om8lNHA2jF
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.QZXghAwomW
+++ mktemp
++ local LAST_ERR=/tmp/tmp.Bo7RZeZRSS
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.QZXghAwomW
++ cat /tmp/tmp.Bo7RZeZRSS
++ rm /tmp/tmp.QZXghAwomW /tmp/tmp.Bo7RZeZRSS
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.et6h8TFdUH
+++ mktemp
++ local LAST_ERR=/tmp/tmp.vBsQM9nYnl
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.et6h8TFdUH
++ cat /tmp/tmp.vBsQM9nYnl
++ rm /tmp/tmp.et6h8TFdUH /tmp/tmp.vBsQM9nYnl
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.RhxemiNFES
+++ mktemp
++ local LAST_ERR=/tmp/tmp.AnTTUaUVzT
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.RhxemiNFES
++ cat /tmp/tmp.AnTTUaUVzT
++ rm /tmp/tmp.RhxemiNFES /tmp/tmp.AnTTUaUVzT
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.iZef1WhtH7
+++ mktemp
++ local LAST_ERR=/tmp/tmp.5mDhw52rPF
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.iZef1WhtH7
++ cat /tmp/tmp.5mDhw52rPF
++ rm /tmp/tmp.iZef1WhtH7 /tmp/tmp.5mDhw52rPF
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.4TyHZdVZLj
+++ mktemp
++ local LAST_ERR=/tmp/tmp.5uzZMyQoIR
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.4TyHZdVZLj
++ cat /tmp/tmp.5uzZMyQoIR
++ rm /tmp/tmp.4TyHZdVZLj /tmp/tmp.5uzZMyQoIR
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.tHFfGZYNbX
+++ mktemp
++ local LAST_ERR=/tmp/tmp.XJ3HksAFHX
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.tHFfGZYNbX
++ cat /tmp/tmp.XJ3HksAFHX
++ rm /tmp/tmp.tHFfGZYNbX /tmp/tmp.XJ3HksAFHX
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.GDmbiCz1o4
+++ mktemp
++ local LAST_ERR=/tmp/tmp.HPPEFQHo04
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.GDmbiCz1o4
++ cat /tmp/tmp.HPPEFQHo04
++ rm /tmp/tmp.GDmbiCz1o4 /tmp/tmp.HPPEFQHo04
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.pY3ggBKXAH
+++ mktemp
++ local LAST_ERR=/tmp/tmp.1Sfnny1rI7
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.pY3ggBKXAH
++ cat /tmp/tmp.1Sfnny1rI7
++ rm /tmp/tmp.pY3ggBKXAH /tmp/tmp.1Sfnny1rI7
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.v0qmN83nL2
+++ mktemp
++ local LAST_ERR=/tmp/tmp.eKYbtB9PIs
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.v0qmN83nL2
++ cat /tmp/tmp.eKYbtB9PIs
++ rm /tmp/tmp.v0qmN83nL2 /tmp/tmp.eKYbtB9PIs
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.4ilmvjA2tf
+++ mktemp
++ local LAST_ERR=/tmp/tmp.Az5cN5jTuj
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.4ilmvjA2tf
++ cat /tmp/tmp.Az5cN5jTuj
++ rm /tmp/tmp.4ilmvjA2tf /tmp/tmp.Az5cN5jTuj
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.OSItmhPPMw
+++ mktemp
++ local LAST_ERR=/tmp/tmp.0xSEO87Jhq
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.OSItmhPPMw
++ cat /tmp/tmp.0xSEO87Jhq
++ rm /tmp/tmp.OSItmhPPMw /tmp/tmp.0xSEO87Jhq
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
++ kubectl_bin get pxc some-name -o 'jsonpath={.status.state}'
+++ mktemp
++ local LAST_OUT=/tmp/tmp.5SYl36AADo
+++ mktemp
++ local LAST_ERR=/tmp/tmp.mpCvifMjxn
++ local exit_status=0
+++ seq 0 2
++ for i in '$(seq 0 2)'
++ set +e
++ kubectl get pxc some-name -o 'jsonpath={.status.state}'
++ exit_status=0
++ set -e
++ '[' 0 '!=' 0 ']'
++ break
++ cat /tmp/tmp.5SYl36AADo
++ cat /tmp/tmp.mpCvifMjxn
++ rm /tmp/tmp.5SYl36AADo /tmp/tmp.mpCvifMjxn
++ return 0
+ [[ error == \r\e\a\d\y ]]
+ echo 'waiting for cluster readyness'
waiting for cluster readyness
+ sleep 20
/mnt/jenkins/workspace/cloud-pxc-operator_PR-1522/e2e-tests/users/../functions: line 90: 11264 Terminated              sleep 20