From fcb26f488a5960f37fd63221954ac5929c031a9e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juraci=20Paix=C3=A3o=20Kr=C3=B6hling?= Date: Wed, 6 Mar 2019 09:52:56 +0100 Subject: [PATCH] Moved from v1alpha1 to v1 (#265) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Juraci Paixão Kröhling --- .codecov.yml | 1 + .travis/release.sh | 4 +- CONTRIBUTING.adoc | 4 +- Makefile | 6 +- README.adoc | 22 +- deploy/crds/jaegertracing_v1_jaeger_cr.yaml | 5 + deploy/crds/jaegertracing_v1_jaeger_crd.yaml | 13 + deploy/examples/agent-as-daemonset.yaml | 2 +- deploy/examples/all-in-one-with-options.yaml | 2 +- deploy/examples/disable-ingress.yaml | 2 +- .../openshift/disable-oauth-proxy.yaml | 2 +- deploy/examples/simple-prod-deploy-es.yaml | 2 +- deploy/examples/simple-prod-with-volumes.yaml | 2 +- deploy/examples/simple-prod.yaml | 2 +- deploy/examples/simple-streaming.yaml | 2 +- deploy/examples/simplest.yaml | 2 +- deploy/examples/with-cassandra.yaml | 2 +- deploy/examples/with-sampling.yaml | 2 +- deploy/olm-catalog/_generated.concat_crd.yaml | 16 + deploy/olm-catalog/jaeger-operator.csv.yaml | 30 +- deploy/role.yaml | 6 + pkg/account/main.go | 16 +- pkg/account/main_test.go | 16 +- pkg/account/oauth-proxy.go | 12 +- pkg/account/oauth_proxy_test.go | 10 +- pkg/apis/addtoscheme_io_v1alpha1.go | 3 +- pkg/apis/addtoscheme_jaegertracing_v1.go | 11 + pkg/apis/jaegertracing/v1/builder.go | 12 + pkg/apis/jaegertracing/v1/doc.go | 4 + pkg/apis/jaegertracing/v1/freeform.go | 40 ++ pkg/apis/jaegertracing/v1/freeform_test.go | 53 ++ pkg/apis/jaegertracing/v1/jaeger_types.go | 202 ++++++++ pkg/apis/jaegertracing/v1/logger.go | 11 + pkg/apis/jaegertracing/v1/options.go | 94 ++++ pkg/apis/jaegertracing/v1/options_test.go | 92 ++++ pkg/apis/jaegertracing/v1/register.go | 19 + .../jaegertracing/v1/zz_generated.deepcopy.go | 466 ++++++++++++++++++ pkg/cmd/start/main.go | 18 +- pkg/config/sampling/sampling.go | 28 +- pkg/config/sampling/sampling_test.go | 22 +- pkg/config/ui/ui.go | 28 +- pkg/config/ui/ui_test.go | 22 +- pkg/controller/add_legacy.go | 10 + .../deployment/deployment_controller.go | 4 +- pkg/controller/jaeger/account.go | 8 +- pkg/controller/jaeger/account_test.go | 32 +- pkg/controller/jaeger/configmap.go | 8 +- pkg/controller/jaeger/configmap_test.go | 32 +- pkg/controller/jaeger/cronjob.go | 4 +- pkg/controller/jaeger/cronjob_test.go | 14 +- pkg/controller/jaeger/daemonset.go | 4 +- pkg/controller/jaeger/daemonset_test.go | 14 +- pkg/controller/jaeger/dependencies_test.go | 6 +- pkg/controller/jaeger/deployment.go | 4 +- pkg/controller/jaeger/deployment_test.go | 18 +- pkg/controller/jaeger/elasticsearch.go | 9 +- pkg/controller/jaeger/elasticsearch_test.go | 20 +- pkg/controller/jaeger/ingress.go | 4 +- pkg/controller/jaeger/ingress_test.go | 14 +- pkg/controller/jaeger/jaeger_controller.go | 20 +- .../jaeger/jaeger_controller_test.go | 18 +- pkg/controller/jaeger/role.go | 4 +- pkg/controller/jaeger/role_test.go | 14 +- pkg/controller/jaeger/rolebinding.go | 4 +- pkg/controller/jaeger/rolebinding_test.go | 14 +- pkg/controller/jaeger/route.go | 4 +- pkg/controller/jaeger/route_test.go | 14 +- pkg/controller/jaeger/secret.go | 8 +- pkg/controller/jaeger/secret_test.go | 32 +- pkg/controller/jaeger/service.go | 8 +- pkg/controller/jaeger/service_test.go | 32 +- pkg/controller/jaeger/status/collector.go | 26 +- .../jaeger/status/collector_test.go | 38 +- pkg/controller/legacy/legacy_controller.go | 84 ++++ pkg/cronjob/es_index_cleaner.go | 24 +- pkg/cronjob/es_index_cleaner_test.go | 6 +- pkg/cronjob/spark_dependencies.go | 26 +- pkg/cronjob/spark_dependencies_test.go | 34 +- pkg/deployment/agent.go | 32 +- pkg/deployment/agent_test.go | 60 +-- pkg/deployment/all-in-one.go | 50 +- pkg/deployment/all-in-one_test.go | 164 +++--- pkg/deployment/args.go | 4 +- pkg/deployment/args_test.go | 8 +- pkg/deployment/collector.go | 44 +- pkg/deployment/collector_test.go | 136 ++--- pkg/deployment/ingester.go | 38 +- pkg/deployment/ingester_test.go | 102 ++-- pkg/deployment/query.go | 42 +- pkg/deployment/query_test.go | 100 ++-- pkg/ingress/query.go | 28 +- pkg/ingress/query_test.go | 18 +- pkg/inject/oauth-proxy.go | 22 +- pkg/inject/oauth-proxy_test.go | 18 +- pkg/inject/sidecar.go | 20 +- pkg/inject/sidecar_test.go | 64 +-- pkg/route/query.go | 26 +- pkg/route/query_test.go | 22 +- pkg/service/agent.go | 12 +- pkg/service/agent_test.go | 4 +- pkg/service/collector.go | 14 +- pkg/service/collector_test.go | 4 +- pkg/service/query.go | 26 +- pkg/service/query_test.go | 8 +- pkg/storage/cassandra_dependencies.go | 46 +- pkg/storage/cassandra_dependencies_test.go | 8 +- pkg/storage/dependency.go | 4 +- pkg/storage/dependency_test.go | 6 +- pkg/storage/elasticsearch.go | 38 +- pkg/storage/elasticsearch_role.go | 6 +- pkg/storage/elasticsearch_role_test.go | 6 +- pkg/storage/elasticsearch_secrets.go | 16 +- pkg/storage/elasticsearch_secrets_test.go | 10 +- pkg/storage/elasticsearch_test.go | 74 +-- pkg/strategy/all-in-one.go | 6 +- pkg/strategy/all-in-one_test.go | 72 +-- pkg/strategy/controller.go | 18 +- pkg/strategy/controller_test.go | 88 ++-- pkg/strategy/production.go | 6 +- pkg/strategy/production_test.go | 32 +- pkg/strategy/streaming.go | 6 +- pkg/strategy/streaming_test.go | 36 +- pkg/util/util.go | 28 +- pkg/util/util_test.go | 180 +++---- test/e2e/all_in_one_test.go | 27 +- test/e2e/cassandra.go | 14 +- test/e2e/daemonset.go | 44 +- test/e2e/es_index_cleaner_test.go | 14 +- test/e2e/jaeger_test.go | 6 +- test/e2e/production_test.go | 19 +- test/e2e/sidecar.go | 40 +- test/e2e/simplest_test.go | 11 +- test/e2e/spark_dependencies_test.go | 24 +- test/e2e/utils.go | 11 +- test/role.yaml | 6 + 135 files changed, 2507 insertions(+), 1384 deletions(-) create mode 100644 deploy/crds/jaegertracing_v1_jaeger_cr.yaml create mode 100644 deploy/crds/jaegertracing_v1_jaeger_crd.yaml create mode 100644 pkg/apis/addtoscheme_jaegertracing_v1.go create mode 100644 pkg/apis/jaegertracing/v1/builder.go create mode 100644 pkg/apis/jaegertracing/v1/doc.go create mode 100644 pkg/apis/jaegertracing/v1/freeform.go create mode 100644 pkg/apis/jaegertracing/v1/freeform_test.go create mode 100644 pkg/apis/jaegertracing/v1/jaeger_types.go create mode 100644 pkg/apis/jaegertracing/v1/logger.go create mode 100644 pkg/apis/jaegertracing/v1/options.go create mode 100644 pkg/apis/jaegertracing/v1/options_test.go create mode 100644 pkg/apis/jaegertracing/v1/register.go create mode 100644 pkg/apis/jaegertracing/v1/zz_generated.deepcopy.go create mode 100644 pkg/controller/add_legacy.go create mode 100644 pkg/controller/legacy/legacy_controller.go diff --git a/.codecov.yml b/.codecov.yml index 73702ed36..3f02eb03c 100644 --- a/.codecov.yml +++ b/.codecov.yml @@ -1,2 +1,3 @@ ignore: - "pkg/apis/io/v1alpha1/zz_generated.deepcopy.go" + - "pkg/apis/jaegertracing/v1/zz_generated.deepcopy.go" diff --git a/.travis/release.sh b/.travis/release.sh index 5aa663238..027728180 100755 --- a/.travis/release.sh +++ b/.travis/release.sh @@ -22,8 +22,8 @@ sed "s/currentCSV: jaeger-operator.*/currentCSV: jaeger-operator.v${OPERATOR_VER sed "s~containerImage: docker.io/jaegertracing/jaeger-operator.*~containerImage: docker.io/${BUILD_IMAGE}~gi" -i deploy/olm-catalog/jaeger-operator.csv.yaml sed "s/name: jaeger-operator\.v.*/name: jaeger-operator.v${OPERATOR_VERSION}/gi" -i deploy/olm-catalog/jaeger-operator.csv.yaml sed "s~image: jaegertracing/jaeger-operator.*~image: ${BUILD_IMAGE}~gi" -i deploy/olm-catalog/jaeger-operator.csv.yaml -## there's a "version: v1alpha1" there somewhere... -sed -E "s/version: ([0-9\.]+).*/version: ${OPERATOR_VERSION}/gi" deploy/olm-catalog/jaeger-operator.csv.yaml +## there's a "version: v1" there somewhere that we want to avoid +sed -E "s/version: ([0-9\.]+).*/version: ${OPERATOR_VERSION}/gi" -i deploy/olm-catalog/jaeger-operator.csv.yaml # changes to test/operator.yaml sed "s~image: jaegertracing/jaeger-operator.*~image: ${BUILD_IMAGE}~gi" -i test/operator.yaml diff --git a/CONTRIBUTING.adoc b/CONTRIBUTING.adoc index 791fcbd17..f852a3b8b 100644 --- a/CONTRIBUTING.adoc +++ b/CONTRIBUTING.adoc @@ -90,7 +90,7 @@ Similar instructions also work for OpenShift, but the target `run-openshift` can ==== Model changes -The Operator SDK generates the `pkg/apis/io/v1alpha1/zz_generated.deepcopy.go` file via the command `make generate`. This should be executed whenever there's a model change (`pkg/apis/io/v1alpha1/types.go`) +The Operator SDK generates the `pkg/apis/jaegertracing/v1/zz_generated.deepcopy.go` file via the command `make generate`. This should be executed whenever there's a model change (`pkg/apis/jaegertracing/v1/jaeger_types.go`) ==== Ingress configuration @@ -113,7 +113,7 @@ To verify that it's working, deploy the `simplest.yaml` and check the ingress ro [source,bash] ---- $ kubectl apply -f deploy/examples/simplest.yaml -jaeger.io.jaegertracing/simplest created +jaeger.jaegertracing.io/simplest created $ kubectl get ingress NAME HOSTS ADDRESS PORTS AGE simplest-query * 192.168.122.69 80 12s diff --git a/Makefile b/Makefile index 5e7dff9df..2d46c7d02 100644 --- a/Makefile +++ b/Makefile @@ -28,7 +28,7 @@ check: .PHONY: ensure-generate-is-noop ensure-generate-is-noop: generate - @git diff -s --exit-code pkg/apis/io/v1alpha1/zz_generated.deepcopy.go || (echo "Build failed: a model has been changed but the deep copy functions aren't up to date. Run 'make generate' and update your PR." && exit 1) + @git diff -s --exit-code pkg/apis/jaegertracing/v1/zz_generated.deepcopy.go || (echo "Build failed: a model has been changed but the deep copy functions aren't up to date. Run 'make generate' and update your PR." && exit 1) .PHONY: format format: @@ -76,7 +76,7 @@ e2e-tests: cassandra es crd build docker push @echo "---" >> deploy/test/namespace-manifests.yaml @cat test/operator.yaml | sed "s~image: jaegertracing\/jaeger-operator\:.*~image: $(BUILD_IMAGE)~gi" >> deploy/test/namespace-manifests.yaml - @go test ./test/e2e/... -kubeconfig $(KUBERNETES_CONFIG) -namespacedMan ../../deploy/test/namespace-manifests.yaml -globalMan ../../deploy/crds/io_v1alpha1_jaeger_crd.yaml -root . + @go test ./test/e2e/... -kubeconfig $(KUBERNETES_CONFIG) -namespacedMan ../../deploy/test/namespace-manifests.yaml -globalMan ../../deploy/crds/jaegertracing_v1_jaeger_crd.yaml -root . .PHONY: run run: crd @@ -98,7 +98,7 @@ clean: .PHONY: crd crd: - @kubectl create -f deploy/crds/io_v1alpha1_jaeger_crd.yaml 2>&1 | grep -v "already exists" || true + @kubectl create -f deploy/crds/jaegertracing_v1_jaeger_crd.yaml 2>&1 | grep -v "already exists" || true .PHONY: ingress ingress: diff --git a/README.adoc b/README.adoc index cad9af30f..6b8f17aa9 100644 --- a/README.adoc +++ b/README.adoc @@ -20,7 +20,7 @@ To install the operator, run: [source,bash] ---- kubectl create namespace observability # <1> -kubectl create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/crds/io_v1alpha1_jaeger_crd.yaml +kubectl create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/crds/jaegertracing_v1_jaeger_crd.yaml kubectl create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/service_account.yaml kubectl create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/role.yaml kubectl create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/role_binding.yaml @@ -51,7 +51,7 @@ The instructions from the previous section also work on OpenShift. Make sure to oc login -u system:admin oc new-project observability # <1> -oc create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/crds/io_v1alpha1_jaeger_crd.yaml +oc create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/crds/jaegertracing_v1_jaeger_crd.yaml oc create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/service_account.yaml oc create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/role.yaml oc create -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/role_binding.yaml @@ -83,7 +83,7 @@ The simplest possible way to install is by creating a YAML file like the followi .simplest.yaml [source,yaml] ---- -apiVersion: io.jaegertracing/v1alpha1 +apiVersion: jaegertracing.io/v1 kind: Jaeger metadata: name: simplest @@ -136,7 +136,7 @@ For reference, here's how a more complex all-in-one instance can be created: .all-in-one.yaml [source,yaml] ---- -apiVersion: io.jaegertracing/v1alpha1 +apiVersion: jaegertracing.io/v1 kind: Jaeger metadata: name: my-jaeger @@ -218,7 +218,7 @@ The only additional information required is to provide the details for accessing [source,yaml] ---- -apiVersion: io.jaegertracing/v1alpha1 +apiVersion: jaegertracing.io/v1 kind: Jaeger metadata: name: simple-streaming @@ -291,7 +291,7 @@ By default, the Jaeger UI is protected with OpenShift's OAuth service and any va [source,yaml] ---- -apiVersion: io.jaegertracing/v1alpha1 +apiVersion: jaegertracing.io/v1 kind: Jaeger metadata: name: disable-oauth-proxy @@ -337,7 +337,7 @@ By default, the Operator expects the agents to be deployed as sidecars to the ta [source,yaml] ---- -apiVersion: io.jaegertracing/v1alpha1 +apiVersion: jaegertracing.io/v1 kind: Jaeger metadata: name: my-jaeger @@ -399,7 +399,7 @@ to use a remote sampler: [source,yaml] ---- -apiVersion: io.jaegertracing/v1alpha1 +apiVersion: jaegertracing.io/v1 kind: Jaeger metadata: name: with-sampling @@ -425,7 +425,7 @@ When the storage type is set to Cassandra, the operator will automatically creat [source,yaml] ---- -apiVersion: io.jaegertracing/v1alpha1 +apiVersion: jaegertracing.io/v1 kind: Jaeger metadata: name: cassandra-without-create-schema @@ -442,7 +442,7 @@ Further aspects of the batch job can be configured as well. An example with all [source,yaml] ---- -apiVersion: io.jaegertracing/v1alpha1 +apiVersion: jaegertracing.io/v1 kind: Jaeger metadata: name: cassandra-with-create-schema @@ -490,5 +490,5 @@ kubectl delete -f https://raw.githubusercontent.com/jaegertracing/jaeger-operato kubectl delete -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/role_binding.yaml kubectl delete -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/role.yaml kubectl delete -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/service_account.yaml -kubectl delete -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/crds/io_v1alpha1_jaeger_crd.yaml +kubectl delete -f https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/crds/jaegertracing_v1_jaeger_crd.yaml ---- diff --git a/deploy/crds/jaegertracing_v1_jaeger_cr.yaml b/deploy/crds/jaegertracing_v1_jaeger_cr.yaml new file mode 100644 index 000000000..192b1698b --- /dev/null +++ b/deploy/crds/jaegertracing_v1_jaeger_cr.yaml @@ -0,0 +1,5 @@ +# see /examples +apiVersion: jaegertracing.io/v1 +kind: Jaeger +metadata: + name: example-jaeger diff --git a/deploy/crds/jaegertracing_v1_jaeger_crd.yaml b/deploy/crds/jaegertracing_v1_jaeger_crd.yaml new file mode 100644 index 000000000..ea5c890b8 --- /dev/null +++ b/deploy/crds/jaegertracing_v1_jaeger_crd.yaml @@ -0,0 +1,13 @@ +apiVersion: apiextensions.k8s.io/v1beta1 +kind: CustomResourceDefinition +metadata: + name: jaegers.jaegertracing.io +spec: + group: jaegertracing.io + names: + kind: Jaeger + listKind: JaegerList + plural: jaegers + singular: jaeger + scope: Namespaced + version: v1 diff --git a/deploy/examples/agent-as-daemonset.yaml b/deploy/examples/agent-as-daemonset.yaml index d57a9b551..bb2853a42 100644 --- a/deploy/examples/agent-as-daemonset.yaml +++ b/deploy/examples/agent-as-daemonset.yaml @@ -1,4 +1,4 @@ -apiVersion: io.jaegertracing/v1alpha1 +apiVersion: jaegertracing.io/v1 kind: Jaeger metadata: name: agent-as-daemonset diff --git a/deploy/examples/all-in-one-with-options.yaml b/deploy/examples/all-in-one-with-options.yaml index 994c678d4..2c83367aa 100644 --- a/deploy/examples/all-in-one-with-options.yaml +++ b/deploy/examples/all-in-one-with-options.yaml @@ -1,4 +1,4 @@ -apiVersion: "io.jaegertracing/v1alpha1" +apiVersion: jaegertracing.io/v1 kind: "Jaeger" metadata: name: "my-jaeger" diff --git a/deploy/examples/disable-ingress.yaml b/deploy/examples/disable-ingress.yaml index 493fa4e8f..6ad864470 100644 --- a/deploy/examples/disable-ingress.yaml +++ b/deploy/examples/disable-ingress.yaml @@ -1,4 +1,4 @@ -apiVersion: io.jaegertracing/v1alpha1 +apiVersion: jaegertracing.io/v1 kind: Jaeger metadata: name: disable-ingress diff --git a/deploy/examples/openshift/disable-oauth-proxy.yaml b/deploy/examples/openshift/disable-oauth-proxy.yaml index dfc2bf8bb..e38aba0b0 100644 --- a/deploy/examples/openshift/disable-oauth-proxy.yaml +++ b/deploy/examples/openshift/disable-oauth-proxy.yaml @@ -1,4 +1,4 @@ -apiVersion: io.jaegertracing/v1alpha1 +apiVersion: jaegertracing.io/v1 kind: Jaeger metadata: name: disable-oauth-proxy diff --git a/deploy/examples/simple-prod-deploy-es.yaml b/deploy/examples/simple-prod-deploy-es.yaml index 05fc0ff4b..73afa9720 100644 --- a/deploy/examples/simple-prod-deploy-es.yaml +++ b/deploy/examples/simple-prod-deploy-es.yaml @@ -1,5 +1,5 @@ # This CR deploys Jaeger and Elasticsearch -apiVersion: io.jaegertracing/v1alpha1 +apiVersion: jaegertracing.io/v1 kind: Jaeger metadata: name: simple-prod diff --git a/deploy/examples/simple-prod-with-volumes.yaml b/deploy/examples/simple-prod-with-volumes.yaml index 5db93759a..7cc6f236f 100644 --- a/deploy/examples/simple-prod-with-volumes.yaml +++ b/deploy/examples/simple-prod-with-volumes.yaml @@ -1,5 +1,5 @@ # setup an elasticsearch with `make es` -apiVersion: io.jaegertracing/v1alpha1 +apiVersion: jaegertracing.io/v1 kind: Jaeger metadata: name: simple-prod diff --git a/deploy/examples/simple-prod.yaml b/deploy/examples/simple-prod.yaml index 52dd1e184..2f7382e62 100644 --- a/deploy/examples/simple-prod.yaml +++ b/deploy/examples/simple-prod.yaml @@ -1,5 +1,5 @@ # setup an elasticsearch with `make es` -apiVersion: io.jaegertracing/v1alpha1 +apiVersion: jaegertracing.io/v1 kind: Jaeger metadata: name: simple-prod diff --git a/deploy/examples/simple-streaming.yaml b/deploy/examples/simple-streaming.yaml index 793317885..f6b5b31df 100644 --- a/deploy/examples/simple-streaming.yaml +++ b/deploy/examples/simple-streaming.yaml @@ -1,6 +1,6 @@ # setup an elasticsearch with `make es` # setup a kafka platform using https://strimzi.io with quickstart instructions -apiVersion: io.jaegertracing/v1alpha1 +apiVersion: jaegertracing.io/v1 kind: Jaeger metadata: name: simple-streaming diff --git a/deploy/examples/simplest.yaml b/deploy/examples/simplest.yaml index 0e78189cc..38eff50dd 100644 --- a/deploy/examples/simplest.yaml +++ b/deploy/examples/simplest.yaml @@ -1,4 +1,4 @@ -apiVersion: io.jaegertracing/v1alpha1 +apiVersion: jaegertracing.io/v1 kind: Jaeger metadata: name: simplest diff --git a/deploy/examples/with-cassandra.yaml b/deploy/examples/with-cassandra.yaml index f282bc203..ed79eaac4 100644 --- a/deploy/examples/with-cassandra.yaml +++ b/deploy/examples/with-cassandra.yaml @@ -1,4 +1,4 @@ -apiVersion: io.jaegertracing/v1alpha1 +apiVersion: jaegertracing.io/v1 kind: Jaeger metadata: name: with-cassandra diff --git a/deploy/examples/with-sampling.yaml b/deploy/examples/with-sampling.yaml index 328bf6d75..eba5f671e 100644 --- a/deploy/examples/with-sampling.yaml +++ b/deploy/examples/with-sampling.yaml @@ -1,4 +1,4 @@ -apiVersion: io.jaegertracing/v1alpha1 +apiVersion: jaegertracing.io/v1 kind: Jaeger metadata: name: with-sampling diff --git a/deploy/olm-catalog/_generated.concat_crd.yaml b/deploy/olm-catalog/_generated.concat_crd.yaml index 987872757..e6f822b10 100644 --- a/deploy/olm-catalog/_generated.concat_crd.yaml +++ b/deploy/olm-catalog/_generated.concat_crd.yaml @@ -11,3 +11,19 @@ spec: singular: jaeger scope: Namespaced version: v1alpha1 + +--- + +apiVersion: apiextensions.k8s.io/v1beta1 +kind: CustomResourceDefinition +metadata: + name: jaegers.jaegertracing.io +spec: + group: jaegertracing.io + names: + kind: Jaeger + listKind: JaegerList + plural: jaegers + singular: jaeger + scope: Namespaced + version: v1 diff --git a/deploy/olm-catalog/jaeger-operator.csv.yaml b/deploy/olm-catalog/jaeger-operator.csv.yaml index 1e5b0d7ba..c6a77ac6b 100644 --- a/deploy/olm-catalog/jaeger-operator.csv.yaml +++ b/deploy/olm-catalog/jaeger-operator.csv.yaml @@ -5,7 +5,7 @@ metadata: alm-examples: |- [ { - "apiVersion": "io.jaegertracing/v1alpha1", + "apiVersion": "jaegertracing.io/v1", "kind": "Jaeger", "metadata": { "name": "my-jaeger" @@ -69,6 +69,9 @@ spec: kind: Jaeger name: jaegers.io.jaegertracing version: v1alpha1 + - kind: Jaeger + name: jaegers.jaegertracing.io + version: v1 description: Provides monitoring and troubleshooting microservices-based distributed systems displayName: jaeger-operator @@ -130,6 +133,31 @@ spec: - routes verbs: - '*' + - apiGroups: + - rbac.authorization.k8s.io + resources: + - roles + - rolebindings + verbs: + - '*' + - apiGroups: + - elasticsearch.jaegertracing.io + resources: + - jaeger + verbs: + - get + - apiGroups: + - logging.openshift.io + resources: + - elasticsearches + verbs: + - '*' + - apiGroups: + - jaegertracing.io + resources: + - '*' + verbs: + - '*' serviceAccountName: jaeger-operator deployments: - name: jaeger-operator diff --git a/deploy/role.yaml b/deploy/role.yaml index ed90b23d9..845f480f3 100644 --- a/deploy/role.yaml +++ b/deploy/role.yaml @@ -78,3 +78,9 @@ rules: - elasticsearches verbs: - '*' +- apiGroups: + - jaegertracing.io + resources: + - '*' + verbs: + - '*' diff --git a/pkg/account/main.go b/pkg/account/main.go index 28f9ffe73..d9a98ea80 100644 --- a/pkg/account/main.go +++ b/pkg/account/main.go @@ -3,24 +3,24 @@ package account import ( "fmt" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) // Get returns all the service accounts to be created for this Jaeger instance -func Get(jaeger *v1alpha1.Jaeger) []*v1.ServiceAccount { - accounts := []*v1.ServiceAccount{} - if jaeger.Spec.Ingress.Security == v1alpha1.IngressSecurityOAuthProxy { +func Get(jaeger *v1.Jaeger) []*corev1.ServiceAccount { + accounts := []*corev1.ServiceAccount{} + if jaeger.Spec.Ingress.Security == v1.IngressSecurityOAuthProxy { accounts = append(accounts, OAuthProxy(jaeger)) } return append(accounts, getMain(jaeger)) } -func getMain(jaeger *v1alpha1.Jaeger) *v1.ServiceAccount { +func getMain(jaeger *v1.Jaeger) *corev1.ServiceAccount { trueVar := true - return &v1.ServiceAccount{ + return &corev1.ServiceAccount{ ObjectMeta: metav1.ObjectMeta{ Name: JaegerServiceAccountFor(jaeger), Namespace: jaeger.Namespace, @@ -45,6 +45,6 @@ func getMain(jaeger *v1alpha1.Jaeger) *v1.ServiceAccount { } } -func JaegerServiceAccountFor(jaeger *v1alpha1.Jaeger) string { +func JaegerServiceAccountFor(jaeger *v1.Jaeger) string { return fmt.Sprintf("%s", jaeger.Name) } diff --git a/pkg/account/main_test.go b/pkg/account/main_test.go index dcb23aa4d..5300f9fe5 100644 --- a/pkg/account/main_test.go +++ b/pkg/account/main_test.go @@ -5,33 +5,33 @@ import ( "github.com/stretchr/testify/assert" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestWithSecurityNil(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestWithOAuthProxyNil") - assert.Equal(t, v1alpha1.IngressSecurityNone, jaeger.Spec.Ingress.Security) + jaeger := v1.NewJaeger("TestWithOAuthProxyNil") + assert.Equal(t, v1.IngressSecurityNone, jaeger.Spec.Ingress.Security) sas := Get(jaeger) assert.Len(t, sas, 1) assert.Equal(t, getMain(jaeger), sas[0]) } func TestWithSecurityNone(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestWithOAuthProxyFalse") - jaeger.Spec.Ingress.Security = v1alpha1.IngressSecurityNone + jaeger := v1.NewJaeger("TestWithOAuthProxyFalse") + jaeger.Spec.Ingress.Security = v1.IngressSecurityNone sas := Get(jaeger) assert.Len(t, sas, 1) assert.Equal(t, getMain(jaeger), sas[0]) } func TestWithSecurityOAuthProxy(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestWithOAuthProxyTrue") - jaeger.Spec.Ingress.Security = v1alpha1.IngressSecurityOAuthProxy + jaeger := v1.NewJaeger("TestWithOAuthProxyTrue") + jaeger.Spec.Ingress.Security = v1.IngressSecurityOAuthProxy assert.Len(t, Get(jaeger), 2) } func TestJaegerName(t *testing.T) { - jaeger := v1alpha1.NewJaeger("foo") + jaeger := v1.NewJaeger("foo") assert.Equal(t, "foo", JaegerServiceAccountFor(jaeger)) } diff --git a/pkg/account/oauth-proxy.go b/pkg/account/oauth-proxy.go index 615f77b1e..7ff65a23e 100644 --- a/pkg/account/oauth-proxy.go +++ b/pkg/account/oauth-proxy.go @@ -3,16 +3,16 @@ package account import ( "fmt" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) // OAuthProxy returns a service account representing a client in the context of the OAuth Proxy -func OAuthProxy(jaeger *v1alpha1.Jaeger) *v1.ServiceAccount { +func OAuthProxy(jaeger *v1.Jaeger) *corev1.ServiceAccount { trueVar := true - return &v1.ServiceAccount{ + return &corev1.ServiceAccount{ TypeMeta: metav1.TypeMeta{ APIVersion: "v1", Kind: "ServiceAccount", @@ -45,10 +45,10 @@ func OAuthProxy(jaeger *v1alpha1.Jaeger) *v1.ServiceAccount { } // OAuthProxyAccountNameFor returns the service account name for this Jaeger instance in the context of the OAuth Proxy -func OAuthProxyAccountNameFor(jaeger *v1alpha1.Jaeger) string { +func OAuthProxyAccountNameFor(jaeger *v1.Jaeger) string { return fmt.Sprintf("%s-ui-proxy", jaeger.Name) } -func getOAuthRedirectReference(jaeger *v1alpha1.Jaeger) string { +func getOAuthRedirectReference(jaeger *v1.Jaeger) string { return fmt.Sprintf(`{"kind":"OAuthRedirectReference","apiVersion":"v1","reference":{"kind":"Route","name":"%s"}}`, jaeger.Name) } diff --git a/pkg/account/oauth_proxy_test.go b/pkg/account/oauth_proxy_test.go index dabe9a5c8..fe267c9f8 100644 --- a/pkg/account/oauth_proxy_test.go +++ b/pkg/account/oauth_proxy_test.go @@ -6,19 +6,19 @@ import ( "github.com/stretchr/testify/assert" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestOAuthRedirectReference(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestOAuthRedirectReference") - jaeger.Spec.Ingress.Security = v1alpha1.IngressSecurityOAuthProxy + jaeger := v1.NewJaeger("TestOAuthRedirectReference") + jaeger.Spec.Ingress.Security = v1.IngressSecurityOAuthProxy assert.Contains(t, getOAuthRedirectReference(jaeger), jaeger.Name) } func TestOAuthProxy(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestOAuthProxy") - jaeger.Spec.Ingress.Security = v1alpha1.IngressSecurityOAuthProxy + jaeger := v1.NewJaeger("TestOAuthProxy") + jaeger.Spec.Ingress.Security = v1.IngressSecurityOAuthProxy assert.Equal(t, OAuthProxy(jaeger).Name, fmt.Sprintf("%s-ui-proxy", jaeger.Name)) } diff --git a/pkg/apis/addtoscheme_io_v1alpha1.go b/pkg/apis/addtoscheme_io_v1alpha1.go index 17fc2628e..1208ee274 100644 --- a/pkg/apis/addtoscheme_io_v1alpha1.go +++ b/pkg/apis/addtoscheme_io_v1alpha1.go @@ -2,10 +2,9 @@ package apis import ( "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" - esv1alpha1 "github.com/jaegertracing/jaeger-operator/pkg/storage/elasticsearch/v1alpha1" ) func init() { // Register the types with the Scheme so the components can map objects to GroupVersionKinds and back - AddToSchemes = append(AddToSchemes, v1alpha1.SchemeBuilder.AddToScheme, esv1alpha1.SchemeBuilder.AddToScheme) + AddToSchemes = append(AddToSchemes, v1alpha1.SchemeBuilder.AddToScheme) } diff --git a/pkg/apis/addtoscheme_jaegertracing_v1.go b/pkg/apis/addtoscheme_jaegertracing_v1.go new file mode 100644 index 000000000..741553ebb --- /dev/null +++ b/pkg/apis/addtoscheme_jaegertracing_v1.go @@ -0,0 +1,11 @@ +package apis + +import ( + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" + esv1alpha1 "github.com/jaegertracing/jaeger-operator/pkg/storage/elasticsearch/v1alpha1" +) + +func init() { + // Register the types with the Scheme so the components can map objects to GroupVersionKinds and back + AddToSchemes = append(AddToSchemes, v1.SchemeBuilder.AddToScheme, esv1alpha1.SchemeBuilder.AddToScheme) +} diff --git a/pkg/apis/jaegertracing/v1/builder.go b/pkg/apis/jaegertracing/v1/builder.go new file mode 100644 index 000000000..b9c5b953e --- /dev/null +++ b/pkg/apis/jaegertracing/v1/builder.go @@ -0,0 +1,12 @@ +package v1 + +import metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + +// NewJaeger returns a new Jaeger instance with the given name +func NewJaeger(name string) *Jaeger { + return &Jaeger{ + ObjectMeta: metav1.ObjectMeta{ + Name: name, + }, + } +} diff --git a/pkg/apis/jaegertracing/v1/doc.go b/pkg/apis/jaegertracing/v1/doc.go new file mode 100644 index 000000000..c03511147 --- /dev/null +++ b/pkg/apis/jaegertracing/v1/doc.go @@ -0,0 +1,4 @@ +// Package v1 contains API Schema definitions for the jaegertracing v1 API group +// +k8s:deepcopy-gen=package,register +// +groupName=jaegertracing.io +package v1 diff --git a/pkg/apis/jaegertracing/v1/freeform.go b/pkg/apis/jaegertracing/v1/freeform.go new file mode 100644 index 000000000..7672c9d54 --- /dev/null +++ b/pkg/apis/jaegertracing/v1/freeform.go @@ -0,0 +1,40 @@ +package v1 + +import ( + "encoding/json" +) + +// FreeForm defines a common options parameter that maintains the hierarchical +// structure of the data, unlike Options which flattens the hierarchy into a +// key/value map where the hierarchy is converted to '.' separated items in the key. +type FreeForm struct { + json []byte +} + +// NewFreeForm build a new FreeForm object based on the given map +func NewFreeForm(o map[string]interface{}) FreeForm { + freeForm := FreeForm{} + if o != nil { + freeForm.json, _ = json.Marshal(o) + } + return freeForm +} + +// UnmarshalJSON implements an alternative parser for this field +func (o *FreeForm) UnmarshalJSON(b []byte) error { + o.json = b + return nil +} + +// MarshalJSON specifies how to convert this object into JSON +func (o FreeForm) MarshalJSON() ([]byte, error) { + if len(o.json) == 0 { + return []byte("{}"), nil + } + return o.json, nil +} + +// IsEmpty determines if the freeform options are empty +func (o FreeForm) IsEmpty() bool { + return len(o.json) == 0 || string(o.json) == "{}" +} diff --git a/pkg/apis/jaegertracing/v1/freeform_test.go b/pkg/apis/jaegertracing/v1/freeform_test.go new file mode 100644 index 000000000..33328bb6d --- /dev/null +++ b/pkg/apis/jaegertracing/v1/freeform_test.go @@ -0,0 +1,53 @@ +package v1 + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestFreeForm(t *testing.T) { + uiconfig := `{"es":{"password":"changeme","server-urls":"http://elasticsearch:9200","username":"elastic"}}` + o := NewFreeForm(map[string]interface{}{ + "es": map[string]interface{}{ + "server-urls": "http://elasticsearch:9200", + "username": "elastic", + "password": "changeme", + }, + }) + json, err := o.MarshalJSON() + assert.NoError(t, err) + assert.NotNil(t, json) + assert.Equal(t, uiconfig, string(o.json)) +} + +func TestFreeFormUnmarhalMarshal(t *testing.T) { + uiconfig := `{"es":{"password":"changeme","server-urls":"http://elasticsearch:9200","username":"elastic"}}` + o := NewFreeForm(nil) + o.UnmarshalJSON([]byte(uiconfig)) + json, err := o.MarshalJSON() + assert.NoError(t, err) + assert.NotNil(t, json) + assert.Equal(t, uiconfig, string(o.json)) +} + +func TestFreeFormIsEmptyFalse(t *testing.T) { + o := NewFreeForm(map[string]interface{}{ + "es": map[string]interface{}{ + "server-urls": "http://elasticsearch:9200", + "username": "elastic", + "password": "changeme", + }, + }) + assert.False(t, o.IsEmpty()) +} + +func TestFreeFormIsEmptyTrue(t *testing.T) { + o := NewFreeForm(map[string]interface{}{}) + assert.True(t, o.IsEmpty()) +} + +func TestFreeFormIsEmptyNilTrue(t *testing.T) { + o := NewFreeForm(nil) + assert.True(t, o.IsEmpty()) +} diff --git a/pkg/apis/jaegertracing/v1/jaeger_types.go b/pkg/apis/jaegertracing/v1/jaeger_types.go new file mode 100644 index 000000000..b6be6f263 --- /dev/null +++ b/pkg/apis/jaegertracing/v1/jaeger_types.go @@ -0,0 +1,202 @@ +package v1 + +import ( + "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "github.com/jaegertracing/jaeger-operator/pkg/storage/elasticsearch/v1alpha1" +) + +// IngressSecurityType represents the possible values for the security type +type IngressSecurityType string + +const ( + // FlagPlatformKubernetes represents the value for the 'platform' flag for Kubernetes + FlagPlatformKubernetes = "kubernetes" + + // FlagPlatformOpenShift represents the value for the 'platform' flag for OpenShift + FlagPlatformOpenShift = "openshift" + + // FlagPlatformAutoDetect represents the "auto-detect" value for the platform flag + FlagPlatformAutoDetect = "auto-detect" + + // FlagProvisionElasticsearchAuto represents the 'auto' value for the 'es-provision' flag + FlagProvisionElasticsearchAuto = "auto" + + // FlagProvisionElasticsearchTrue represents the value 'true' for the 'es-provision' flag + FlagProvisionElasticsearchTrue = "true" + + // FlagProvisionElasticsearchFalse represents the value 'false' for the 'es-provision' flag + FlagProvisionElasticsearchFalse = "false" + + // IngressSecurityNone disables any form of security for ingress objects (default) + IngressSecurityNone IngressSecurityType = "" + + // IngressSecurityNoneExplicit used when the user specifically set it to 'none' + IngressSecurityNoneExplicit IngressSecurityType = "none" + + // IngressSecurityOAuthProxy represents an OAuth Proxy as security type + IngressSecurityOAuthProxy IngressSecurityType = "oauth-proxy" +) + +// JaegerSpec defines the desired state of Jaeger +type JaegerSpec struct { + Strategy string `json:"strategy"` + AllInOne JaegerAllInOneSpec `json:"allInOne"` + Query JaegerQuerySpec `json:"query"` + Collector JaegerCollectorSpec `json:"collector"` + Ingester JaegerIngesterSpec `json:"ingester"` + Agent JaegerAgentSpec `json:"agent"` + UI JaegerUISpec `json:"ui"` + Sampling JaegerSamplingSpec `json:"sampling"` + Storage JaegerStorageSpec `json:"storage"` + Ingress JaegerIngressSpec `json:"ingress"` + JaegerCommonSpec +} + +// JaegerStatus defines the observed state of Jaeger +type JaegerStatus struct { + // CollectorSpansReceived represents sum of the metric jaeger_collector_spans_received_total across all collectors + CollectorSpansReceived int `json:"collectorSpansReceived"` + + // CollectorSpansDropped represents sum of the metric jaeger_collector_spans_dropped_total across all collectors + CollectorSpansDropped int `json:"collectorSpansDropped"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// Jaeger is the Schema for the jaegers API +type Jaeger struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + + Spec JaegerSpec `json:"spec,omitempty"` + Status JaegerStatus `json:"status,omitempty"` +} + +// JaegerCommonSpec defines the common elements used in multiple other spec structs +type JaegerCommonSpec struct { + Volumes []v1.Volume `json:"volumes"` + VolumeMounts []v1.VolumeMount `json:"volumeMounts"` + Annotations map[string]string `json:"annotations,omitempty"` + Resources v1.ResourceRequirements `json:"resources,omitempty"` +} + +// JaegerQuerySpec defines the options to be used when deploying the query +type JaegerQuerySpec struct { + Size int `json:"size"` + Image string `json:"image"` + Options Options `json:"options"` + JaegerCommonSpec +} + +// JaegerUISpec defines the options to be used to configure the UI +type JaegerUISpec struct { + Options FreeForm `json:"options"` +} + +// JaegerSamplingSpec defines the options to be used to configure the UI +type JaegerSamplingSpec struct { + Options FreeForm `json:"options"` +} + +// JaegerIngressSpec defines the options to be used when deploying the query ingress +type JaegerIngressSpec struct { + Enabled *bool `json:"enabled"` + Security IngressSecurityType `json:"security"` + JaegerCommonSpec +} + +// JaegerAllInOneSpec defines the options to be used when deploying the query +type JaegerAllInOneSpec struct { + Image string `json:"image"` + Options Options `json:"options"` + JaegerCommonSpec +} + +// JaegerCollectorSpec defines the options to be used when deploying the collector +type JaegerCollectorSpec struct { + Size int `json:"size"` + Image string `json:"image"` + Options Options `json:"options"` + JaegerCommonSpec +} + +// JaegerIngesterSpec defines the options to be used when deploying the ingester +type JaegerIngesterSpec struct { + Size int `json:"size"` + Image string `json:"image"` + Options Options `json:"options"` + JaegerCommonSpec +} + +// JaegerAgentSpec defines the options to be used when deploying the agent +type JaegerAgentSpec struct { + Strategy string `json:"strategy"` // can be either 'DaemonSet' or 'Sidecar' (default) + Image string `json:"image"` + Options Options `json:"options"` + JaegerCommonSpec +} + +// JaegerStorageSpec defines the common storage options to be used for the query and collector +type JaegerStorageSpec struct { + Type string `json:"type"` // can be `memory` (default), `cassandra`, `elasticsearch`, `kafka` or `managed` + SecretName string `json:"secretName"` + Options Options `json:"options"` + CassandraCreateSchema JaegerCassandraCreateSchemaSpec `json:"cassandraCreateSchema"` + SparkDependencies JaegerDependenciesSpec `json:"dependencies"` + EsIndexCleaner JaegerEsIndexCleanerSpec `json:"esIndexCleaner"` + Elasticsearch ElasticsearchSpec `json:"elasticsearch"` +} + +// ElasticsearchSpec represents the ES configuration options that we pass down to the Elasticsearch operator +type ElasticsearchSpec struct { + Resources v1.ResourceRequirements `json:"resources"` + NodeCount int32 `json:"nodeCount"` + NodeSelector map[string]string `json:"nodeSelector,omitempty"` + Storage v1alpha1.ElasticsearchStorageSpec `json:"storage"` + RedundancyPolicy v1alpha1.RedundancyPolicyType `json:"redundancyPolicy"` +} + +// JaegerCassandraCreateSchemaSpec holds the options related to the create-schema batch job +type JaegerCassandraCreateSchemaSpec struct { + Enabled *bool `json:"enabled"` + Image string `json:"image"` + Datacenter string `json:"datacenter"` + Mode string `json:"mode"` +} + +// JaegerDependenciesSpec defined options for running spark-dependencies. +type JaegerDependenciesSpec struct { + Enabled *bool `json:"enabled"` + SparkMaster string `json:"sparkMaster"` + Schedule string `json:"schedule"` + Image string `json:"image"` + JavaOpts string `json:"javaOpts"` + CassandraUseSsl bool `json:"cassandraUseSsl"` + CassandraLocalDc string `json:"cassandraLocalDc"` + CassandraClientAuthEnabled bool `json:"cassandraClientAuthEnabled"` + ElasticsearchClientNodeOnly bool `json:"elasticsearchClientNodeOnly"` + ElasticsearchNodesWanOnly bool `json:"elasticsearchNodesWanOnly"` +} + +// JaegerEsIndexCleanerSpec holds the options related to es-index-cleaner +type JaegerEsIndexCleanerSpec struct { + Enabled *bool `json:"enabled"` + NumberOfDays int `json:"numberOfDays"` + Schedule string `json:"schedule"` + Image string `json:"image"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// JaegerList contains a list of Jaeger +type JaegerList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + Items []Jaeger `json:"items"` +} + +func init() { + SchemeBuilder.Register(&Jaeger{}, &JaegerList{}) +} diff --git a/pkg/apis/jaegertracing/v1/logger.go b/pkg/apis/jaegertracing/v1/logger.go new file mode 100644 index 000000000..a90e8ad4c --- /dev/null +++ b/pkg/apis/jaegertracing/v1/logger.go @@ -0,0 +1,11 @@ +package v1 + +import log "github.com/sirupsen/logrus" + +// Logger returns a logger filled with context-related fields, such as Name and Namespace +func (j *Jaeger) Logger() *log.Entry { + return log.WithFields(log.Fields{ + "instance": j.Name, + "namespace": j.Namespace, + }) +} diff --git a/pkg/apis/jaegertracing/v1/options.go b/pkg/apis/jaegertracing/v1/options.go new file mode 100644 index 000000000..68ee4d542 --- /dev/null +++ b/pkg/apis/jaegertracing/v1/options.go @@ -0,0 +1,94 @@ +package v1 + +import ( + "encoding/json" + "fmt" + "strings" +) + +// Options defines a common options parameter to the different structs +type Options struct { + opts map[string]string +} + +// NewOptions build a new Options object based on the given map +func NewOptions(o map[string]interface{}) Options { + options := Options{} + options.parse(o) + return options +} + +// Filter creates a new Options object with just the elements identified by the supplied prefix +func (o *Options) Filter(prefix string) Options { + options := Options{} + options.opts = make(map[string]string) + + archivePrefix := prefix + "-archive." + prefix += "." + + for k, v := range o.opts { + if strings.HasPrefix(k, prefix) || strings.HasPrefix(k, archivePrefix) { + options.opts[k] = v + } + } + + return options +} + +// UnmarshalJSON implements an alternative parser for this field +func (o *Options) UnmarshalJSON(b []byte) error { + var entries map[string]interface{} + json.Unmarshal(b, &entries) + + return o.parse(entries) +} + +// MarshalJSON specifies how to convert this object into JSON +func (o Options) MarshalJSON() ([]byte, error) { + b, err := json.Marshal(o.opts) + return b, err +} + +func (o *Options) parse(entries map[string]interface{}) error { + o.opts = make(map[string]string) + + for k, v := range entries { + o.opts = entry(o.opts, k, v) + } + + return nil +} + +func entry(entries map[string]string, key string, value interface{}) map[string]string { + switch value.(type) { + case map[string]interface{}: + for k, v := range value.(map[string]interface{}) { + entries = entry(entries, fmt.Sprintf("%s.%v", key, k), v) + } + case interface{}: + entries[key] = fmt.Sprintf("%v", value) + } + + return entries +} + +// ToArgs converts the options to a value suitable for the Container.Args field +func (o *Options) ToArgs() []string { + if len(o.opts) > 0 { + i := 0 + args := make([]string, len(o.opts)) + for k, v := range o.opts { + args[i] = fmt.Sprintf("--%s=%v", k, v) + i++ + } + return args + } + + return nil +} + +// Map returns a map representing the option entries. Items are flattened, with dots as separators. For instance +// an option "cassandra" with a nested "servers" object becomes an entry with the key "cassandra.servers" +func (o *Options) Map() map[string]string { + return o.opts +} diff --git a/pkg/apis/jaegertracing/v1/options_test.go b/pkg/apis/jaegertracing/v1/options_test.go new file mode 100644 index 000000000..51d5c6b6c --- /dev/null +++ b/pkg/apis/jaegertracing/v1/options_test.go @@ -0,0 +1,92 @@ +package v1 + +import ( + "encoding/json" + "sort" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestSimpleOption(t *testing.T) { + o := Options{} + o.UnmarshalJSON([]byte(`{"key": "value"}`)) + args := o.ToArgs() + assert.Equal(t, "--key=value", args[0]) +} + +func TestNoOptions(t *testing.T) { + o := Options{} + assert.Len(t, o.ToArgs(), 0) +} + +func TestNestedOption(t *testing.T) { + o := NewOptions(nil) + o.UnmarshalJSON([]byte(`{"log-level": "debug", "memory": {"max-traces": 10000}}`)) + args := o.ToArgs() + assert.Len(t, args, 2) + + sort.Strings(args) + assert.Equal(t, "--log-level=debug", args[0]) + assert.Equal(t, "--memory.max-traces=10000", args[1]) +} + +func TestMarshalling(t *testing.T) { + o := NewOptions(map[string]interface{}{ + "es.server-urls": "http://elasticsearch.default.svc:9200", + "es.username": "elastic", + "es.password": "changeme", + }) + + b, err := json.Marshal(o) + assert.NoError(t, err) + s := string(b) + assert.Contains(t, s, `"es.password":"changeme"`) + assert.Contains(t, s, `"es.server-urls":"http://elasticsearch.default.svc:9200"`) + assert.Contains(t, s, `"es.username":"elastic"`) +} + +func TestMarshallingWithFilter(t *testing.T) { + o := NewOptions(map[string]interface{}{ + "es.server-urls": "http://elasticsearch.default.svc:9200", + "memory.max-traces": "50000", + }) + o = o.Filter("memory") + args := o.ToArgs() + assert.Len(t, args, 1) + assert.Equal(t, "50000", o.Map()["memory.max-traces"]) +} + +func TestMultipleSubValues(t *testing.T) { + o := NewOptions(nil) + o.UnmarshalJSON([]byte(`{"es": {"server-urls": "http://elasticsearch:9200", "username": "elastic", "password": "changeme"}}`)) + args := o.ToArgs() + assert.Len(t, args, 3) +} + +func TestMultipleSubValuesWithFilter(t *testing.T) { + o := NewOptions(nil) + o.UnmarshalJSON([]byte(`{"memory": {"max-traces": "50000"}, "es": {"server-urls": "http://elasticsearch:9200", "username": "elastic", "password": "changeme"}}`)) + o = o.Filter("memory") + args := o.ToArgs() + assert.Len(t, args, 1) + assert.Equal(t, "50000", o.Map()["memory.max-traces"]) +} + +func TestMultipleSubValuesWithFilterWithArchive(t *testing.T) { + o := NewOptions(nil) + o.UnmarshalJSON([]byte(`{"memory": {"max-traces": "50000"}, "es": {"server-urls": "http://elasticsearch:9200", "username": "elastic", "password": "changeme"}, "es-archive": {"server-urls": "http://elasticsearch2:9200"}}`)) + o = o.Filter("es") + args := o.ToArgs() + assert.Len(t, args, 4) + assert.Equal(t, "http://elasticsearch:9200", o.Map()["es.server-urls"]) + assert.Equal(t, "http://elasticsearch2:9200", o.Map()["es-archive.server-urls"]) + assert.Equal(t, "elastic", o.Map()["es.username"]) + assert.Equal(t, "changeme", o.Map()["es.password"]) +} + +func TestExposedMap(t *testing.T) { + o := NewOptions(nil) + o.UnmarshalJSON([]byte(`{"cassandra": {"servers": "cassandra:9042"}}`)) + assert.Equal(t, "cassandra:9042", o.Map()["cassandra.servers"]) +} diff --git a/pkg/apis/jaegertracing/v1/register.go b/pkg/apis/jaegertracing/v1/register.go new file mode 100644 index 000000000..f54f775db --- /dev/null +++ b/pkg/apis/jaegertracing/v1/register.go @@ -0,0 +1,19 @@ +// NOTE: Boilerplate only. Ignore this file. + +// Package v1 contains API Schema definitions for the jaegertracing v1 API group +// +k8s:deepcopy-gen=package,register +// +groupName=jaegertracing.io +package v1 + +import ( + "k8s.io/apimachinery/pkg/runtime/schema" + "sigs.k8s.io/controller-runtime/pkg/runtime/scheme" +) + +var ( + // SchemeGroupVersion is group version used to register these objects + SchemeGroupVersion = schema.GroupVersion{Group: "jaegertracing.io", Version: "v1"} + + // SchemeBuilder is used to add go types to the GroupVersionKind scheme + SchemeBuilder = &scheme.Builder{GroupVersion: SchemeGroupVersion} +) diff --git a/pkg/apis/jaegertracing/v1/zz_generated.deepcopy.go b/pkg/apis/jaegertracing/v1/zz_generated.deepcopy.go new file mode 100644 index 000000000..10cee7448 --- /dev/null +++ b/pkg/apis/jaegertracing/v1/zz_generated.deepcopy.go @@ -0,0 +1,466 @@ +// +build !ignore_autogenerated + +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by deepcopy-gen. DO NOT EDIT. + +package v1 + +import ( + corev1 "k8s.io/api/core/v1" + runtime "k8s.io/apimachinery/pkg/runtime" +) + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ElasticsearchSpec) DeepCopyInto(out *ElasticsearchSpec) { + *out = *in + in.Resources.DeepCopyInto(&out.Resources) + if in.NodeSelector != nil { + in, out := &in.NodeSelector, &out.NodeSelector + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + in.Storage.DeepCopyInto(&out.Storage) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ElasticsearchSpec. +func (in *ElasticsearchSpec) DeepCopy() *ElasticsearchSpec { + if in == nil { + return nil + } + out := new(ElasticsearchSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *FreeForm) DeepCopyInto(out *FreeForm) { + *out = *in + if in.json != nil { + in, out := &in.json, &out.json + *out = make([]byte, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FreeForm. +func (in *FreeForm) DeepCopy() *FreeForm { + if in == nil { + return nil + } + out := new(FreeForm) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Jaeger) DeepCopyInto(out *Jaeger) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + out.Status = in.Status + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Jaeger. +func (in *Jaeger) DeepCopy() *Jaeger { + if in == nil { + return nil + } + out := new(Jaeger) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *Jaeger) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JaegerAgentSpec) DeepCopyInto(out *JaegerAgentSpec) { + *out = *in + in.Options.DeepCopyInto(&out.Options) + in.JaegerCommonSpec.DeepCopyInto(&out.JaegerCommonSpec) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerAgentSpec. +func (in *JaegerAgentSpec) DeepCopy() *JaegerAgentSpec { + if in == nil { + return nil + } + out := new(JaegerAgentSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JaegerAllInOneSpec) DeepCopyInto(out *JaegerAllInOneSpec) { + *out = *in + in.Options.DeepCopyInto(&out.Options) + in.JaegerCommonSpec.DeepCopyInto(&out.JaegerCommonSpec) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerAllInOneSpec. +func (in *JaegerAllInOneSpec) DeepCopy() *JaegerAllInOneSpec { + if in == nil { + return nil + } + out := new(JaegerAllInOneSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JaegerCassandraCreateSchemaSpec) DeepCopyInto(out *JaegerCassandraCreateSchemaSpec) { + *out = *in + if in.Enabled != nil { + in, out := &in.Enabled, &out.Enabled + *out = new(bool) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerCassandraCreateSchemaSpec. +func (in *JaegerCassandraCreateSchemaSpec) DeepCopy() *JaegerCassandraCreateSchemaSpec { + if in == nil { + return nil + } + out := new(JaegerCassandraCreateSchemaSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JaegerCollectorSpec) DeepCopyInto(out *JaegerCollectorSpec) { + *out = *in + in.Options.DeepCopyInto(&out.Options) + in.JaegerCommonSpec.DeepCopyInto(&out.JaegerCommonSpec) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerCollectorSpec. +func (in *JaegerCollectorSpec) DeepCopy() *JaegerCollectorSpec { + if in == nil { + return nil + } + out := new(JaegerCollectorSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JaegerCommonSpec) DeepCopyInto(out *JaegerCommonSpec) { + *out = *in + if in.Volumes != nil { + in, out := &in.Volumes, &out.Volumes + *out = make([]corev1.Volume, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.VolumeMounts != nil { + in, out := &in.VolumeMounts, &out.VolumeMounts + *out = make([]corev1.VolumeMount, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.Annotations != nil { + in, out := &in.Annotations, &out.Annotations + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + in.Resources.DeepCopyInto(&out.Resources) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerCommonSpec. +func (in *JaegerCommonSpec) DeepCopy() *JaegerCommonSpec { + if in == nil { + return nil + } + out := new(JaegerCommonSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JaegerDependenciesSpec) DeepCopyInto(out *JaegerDependenciesSpec) { + *out = *in + if in.Enabled != nil { + in, out := &in.Enabled, &out.Enabled + *out = new(bool) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerDependenciesSpec. +func (in *JaegerDependenciesSpec) DeepCopy() *JaegerDependenciesSpec { + if in == nil { + return nil + } + out := new(JaegerDependenciesSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JaegerEsIndexCleanerSpec) DeepCopyInto(out *JaegerEsIndexCleanerSpec) { + *out = *in + if in.Enabled != nil { + in, out := &in.Enabled, &out.Enabled + *out = new(bool) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerEsIndexCleanerSpec. +func (in *JaegerEsIndexCleanerSpec) DeepCopy() *JaegerEsIndexCleanerSpec { + if in == nil { + return nil + } + out := new(JaegerEsIndexCleanerSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JaegerIngesterSpec) DeepCopyInto(out *JaegerIngesterSpec) { + *out = *in + in.Options.DeepCopyInto(&out.Options) + in.JaegerCommonSpec.DeepCopyInto(&out.JaegerCommonSpec) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerIngesterSpec. +func (in *JaegerIngesterSpec) DeepCopy() *JaegerIngesterSpec { + if in == nil { + return nil + } + out := new(JaegerIngesterSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JaegerIngressSpec) DeepCopyInto(out *JaegerIngressSpec) { + *out = *in + if in.Enabled != nil { + in, out := &in.Enabled, &out.Enabled + *out = new(bool) + **out = **in + } + in.JaegerCommonSpec.DeepCopyInto(&out.JaegerCommonSpec) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerIngressSpec. +func (in *JaegerIngressSpec) DeepCopy() *JaegerIngressSpec { + if in == nil { + return nil + } + out := new(JaegerIngressSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JaegerList) DeepCopyInto(out *JaegerList) { + *out = *in + out.TypeMeta = in.TypeMeta + out.ListMeta = in.ListMeta + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]Jaeger, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerList. +func (in *JaegerList) DeepCopy() *JaegerList { + if in == nil { + return nil + } + out := new(JaegerList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *JaegerList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JaegerQuerySpec) DeepCopyInto(out *JaegerQuerySpec) { + *out = *in + in.Options.DeepCopyInto(&out.Options) + in.JaegerCommonSpec.DeepCopyInto(&out.JaegerCommonSpec) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerQuerySpec. +func (in *JaegerQuerySpec) DeepCopy() *JaegerQuerySpec { + if in == nil { + return nil + } + out := new(JaegerQuerySpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JaegerSamplingSpec) DeepCopyInto(out *JaegerSamplingSpec) { + *out = *in + in.Options.DeepCopyInto(&out.Options) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerSamplingSpec. +func (in *JaegerSamplingSpec) DeepCopy() *JaegerSamplingSpec { + if in == nil { + return nil + } + out := new(JaegerSamplingSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JaegerSpec) DeepCopyInto(out *JaegerSpec) { + *out = *in + in.AllInOne.DeepCopyInto(&out.AllInOne) + in.Query.DeepCopyInto(&out.Query) + in.Collector.DeepCopyInto(&out.Collector) + in.Ingester.DeepCopyInto(&out.Ingester) + in.Agent.DeepCopyInto(&out.Agent) + in.UI.DeepCopyInto(&out.UI) + in.Sampling.DeepCopyInto(&out.Sampling) + in.Storage.DeepCopyInto(&out.Storage) + in.Ingress.DeepCopyInto(&out.Ingress) + in.JaegerCommonSpec.DeepCopyInto(&out.JaegerCommonSpec) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerSpec. +func (in *JaegerSpec) DeepCopy() *JaegerSpec { + if in == nil { + return nil + } + out := new(JaegerSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JaegerStatus) DeepCopyInto(out *JaegerStatus) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerStatus. +func (in *JaegerStatus) DeepCopy() *JaegerStatus { + if in == nil { + return nil + } + out := new(JaegerStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JaegerStorageSpec) DeepCopyInto(out *JaegerStorageSpec) { + *out = *in + in.Options.DeepCopyInto(&out.Options) + in.CassandraCreateSchema.DeepCopyInto(&out.CassandraCreateSchema) + in.SparkDependencies.DeepCopyInto(&out.SparkDependencies) + in.EsIndexCleaner.DeepCopyInto(&out.EsIndexCleaner) + in.Elasticsearch.DeepCopyInto(&out.Elasticsearch) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerStorageSpec. +func (in *JaegerStorageSpec) DeepCopy() *JaegerStorageSpec { + if in == nil { + return nil + } + out := new(JaegerStorageSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *JaegerUISpec) DeepCopyInto(out *JaegerUISpec) { + *out = *in + in.Options.DeepCopyInto(&out.Options) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerUISpec. +func (in *JaegerUISpec) DeepCopy() *JaegerUISpec { + if in == nil { + return nil + } + out := new(JaegerUISpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Options) DeepCopyInto(out *Options) { + *out = *in + if in.opts != nil { + in, out := &in.opts, &out.opts + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Options. +func (in *Options) DeepCopy() *Options { + if in == nil { + return nil + } + out := new(Options) + in.DeepCopyInto(out) + return out +} diff --git a/pkg/cmd/start/main.go b/pkg/cmd/start/main.go index d917e06a3..4c05873d1 100644 --- a/pkg/cmd/start/main.go +++ b/pkg/cmd/start/main.go @@ -16,7 +16,7 @@ import ( "sigs.k8s.io/controller-runtime/pkg/runtime/signals" "github.com/jaegertracing/jaeger-operator/pkg/apis" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/controller" "github.com/jaegertracing/jaeger-operator/pkg/version" ) @@ -110,16 +110,16 @@ func start(cmd *cobra.Command, args []string) { apiList, err := availableAPIs(mgr.GetConfig()) if err != nil { log.WithError(err).Info("Failed to determine the platform capabilities. Auto-detected properties will fallback to their default values.") - viper.Set("platform", v1alpha1.FlagPlatformKubernetes) - viper.Set("es-provision", v1alpha1.FlagProvisionElasticsearchFalse) + viper.Set("platform", v1.FlagPlatformKubernetes) + viper.Set("es-provision", v1.FlagProvisionElasticsearchFalse) } else { // detect the platform - if strings.EqualFold(viper.GetString("platform"), v1alpha1.FlagPlatformAutoDetect) { + if strings.EqualFold(viper.GetString("platform"), v1.FlagPlatformAutoDetect) { log.Debug("Attempting to auto-detect the platform") if isOpenShift(apiList) { - viper.Set("platform", v1alpha1.FlagPlatformOpenShift) + viper.Set("platform", v1.FlagPlatformOpenShift) } else { - viper.Set("platform", v1alpha1.FlagPlatformKubernetes) + viper.Set("platform", v1.FlagPlatformKubernetes) } log.WithField("platform", viper.GetString("platform")).Info("Auto-detected the platform") @@ -128,12 +128,12 @@ func start(cmd *cobra.Command, args []string) { } // detect whether the Elasticsearch operator is available - if strings.EqualFold(viper.GetString("es-provision"), v1alpha1.FlagProvisionElasticsearchAuto) { + if strings.EqualFold(viper.GetString("es-provision"), v1.FlagProvisionElasticsearchAuto) { log.Debug("Determining whether we should enable the Elasticsearch Operator integration") if isElasticsearchOperatorAvailable(apiList) { - viper.Set("es-provision", v1alpha1.FlagProvisionElasticsearchTrue) + viper.Set("es-provision", v1.FlagProvisionElasticsearchTrue) } else { - viper.Set("es-provision", v1alpha1.FlagProvisionElasticsearchFalse) + viper.Set("es-provision", v1.FlagProvisionElasticsearchFalse) } log.WithField("es-provision", viper.GetString("es-provision")).Info("Automatically adjusted the 'es-provision' flag") diff --git a/pkg/config/sampling/sampling.go b/pkg/config/sampling/sampling.go index 151c78247..3540e0542 100644 --- a/pkg/config/sampling/sampling.go +++ b/pkg/config/sampling/sampling.go @@ -3,10 +3,10 @@ package sampling import ( "fmt" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) const ( @@ -15,16 +15,16 @@ const ( // Config represents a sampling configmap type Config struct { - jaeger *v1alpha1.Jaeger + jaeger *v1.Jaeger } // NewConfig builds a new Config struct based on the given spec -func NewConfig(jaeger *v1alpha1.Jaeger) *Config { +func NewConfig(jaeger *v1.Jaeger) *Config { return &Config{jaeger: jaeger} } // Get returns a configmap specification for the current instance -func (u *Config) Get() *v1.ConfigMap { +func (u *Config) Get() *corev1.ConfigMap { var jsonObject []byte var err error @@ -46,7 +46,7 @@ func (u *Config) Get() *v1.ConfigMap { "sampling": string(jsonObject), } - return &v1.ConfigMap{ + return &corev1.ConfigMap{ TypeMeta: metav1.TypeMeta{ APIVersion: "v1", Kind: "ConfigMap", @@ -78,17 +78,17 @@ func (u *Config) Get() *v1.ConfigMap { // Update will modify the supplied common spec and options to include // support for the Sampling configmap. -func Update(jaeger *v1alpha1.Jaeger, commonSpec *v1alpha1.JaegerCommonSpec, options *[]string) { +func Update(jaeger *v1.Jaeger, commonSpec *v1.JaegerCommonSpec, options *[]string) { - volume := v1.Volume{ + volume := corev1.Volume{ Name: fmt.Sprintf("%s-sampling-configuration-volume", jaeger.Name), - VolumeSource: v1.VolumeSource{ - ConfigMap: &v1.ConfigMapVolumeSource{ - LocalObjectReference: v1.LocalObjectReference{ + VolumeSource: corev1.VolumeSource{ + ConfigMap: &corev1.ConfigMapVolumeSource{ + LocalObjectReference: corev1.LocalObjectReference{ Name: fmt.Sprintf("%s-sampling-configuration", jaeger.Name), }, - Items: []v1.KeyToPath{ - v1.KeyToPath{ + Items: []corev1.KeyToPath{ + corev1.KeyToPath{ Key: "sampling", Path: "sampling.json", }, @@ -96,7 +96,7 @@ func Update(jaeger *v1alpha1.Jaeger, commonSpec *v1alpha1.JaegerCommonSpec, opti }, }, } - volumeMount := v1.VolumeMount{ + volumeMount := corev1.VolumeMount{ Name: fmt.Sprintf("%s-sampling-configuration-volume", jaeger.Name), MountPath: "/etc/jaeger/sampling", ReadOnly: true, diff --git a/pkg/config/sampling/sampling_test.go b/pkg/config/sampling/sampling_test.go index 796e8debf..92170963a 100644 --- a/pkg/config/sampling/sampling_test.go +++ b/pkg/config/sampling/sampling_test.go @@ -5,11 +5,11 @@ import ( "github.com/stretchr/testify/assert" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestNoSamplingConfig(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestNoSamplingConfig") + jaeger := v1.NewJaeger("TestNoSamplingConfig") config := NewConfig(jaeger) cm := config.Get() @@ -18,8 +18,8 @@ func TestNoSamplingConfig(t *testing.T) { } func TestWithEmptySamplingConfig(t *testing.T) { - uiconfig := v1alpha1.NewFreeForm(map[string]interface{}{}) - jaeger := v1alpha1.NewJaeger("TestWithEmptySamplingConfig") + uiconfig := v1.NewFreeForm(map[string]interface{}{}) + jaeger := v1.NewJaeger("TestWithEmptySamplingConfig") jaeger.Spec.UI.Options = uiconfig config := NewConfig(jaeger) @@ -29,14 +29,14 @@ func TestWithEmptySamplingConfig(t *testing.T) { } func TestWithSamplingConfig(t *testing.T) { - samplingconfig := v1alpha1.NewFreeForm(map[string]interface{}{ + samplingconfig := v1.NewFreeForm(map[string]interface{}{ "default_strategy": map[string]interface{}{ "type": "probabilistic", "param": "20", }, }) json := `{"default_strategy":{"param":"20","type":"probabilistic"}}` - jaeger := v1alpha1.NewJaeger("TestWithSamplingConfig") + jaeger := v1.NewJaeger("TestWithSamplingConfig") jaeger.Spec.Sampling.Options = samplingconfig config := NewConfig(jaeger) @@ -45,9 +45,9 @@ func TestWithSamplingConfig(t *testing.T) { } func TestUpdateNoSamplingConfig(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestUpdateNoSamplingConfig") + jaeger := v1.NewJaeger("TestUpdateNoSamplingConfig") - commonSpec := v1alpha1.JaegerCommonSpec{} + commonSpec := v1.JaegerCommonSpec{} options := []string{} Update(jaeger, &commonSpec, &options) @@ -60,15 +60,15 @@ func TestUpdateNoSamplingConfig(t *testing.T) { } func TestUpdateWithSamplingConfig(t *testing.T) { - uiconfig := v1alpha1.NewFreeForm(map[string]interface{}{ + uiconfig := v1.NewFreeForm(map[string]interface{}{ "tracking": map[string]interface{}{ "gaID": "UA-000000-2", }, }) - jaeger := v1alpha1.NewJaeger("TestUpdateWithSamplingConfig") + jaeger := v1.NewJaeger("TestUpdateWithSamplingConfig") jaeger.Spec.UI.Options = uiconfig - commonSpec := v1alpha1.JaegerCommonSpec{} + commonSpec := v1.JaegerCommonSpec{} options := []string{} Update(jaeger, &commonSpec, &options) diff --git a/pkg/config/ui/ui.go b/pkg/config/ui/ui.go index 4b71b7429..d7cef7512 100644 --- a/pkg/config/ui/ui.go +++ b/pkg/config/ui/ui.go @@ -3,24 +3,24 @@ package configmap import ( "fmt" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) // UIConfig represents a UI configmap type UIConfig struct { - jaeger *v1alpha1.Jaeger + jaeger *v1.Jaeger } // NewUIConfig builds a new UIConfig struct based on the given spec -func NewUIConfig(jaeger *v1alpha1.Jaeger) *UIConfig { +func NewUIConfig(jaeger *v1.Jaeger) *UIConfig { return &UIConfig{jaeger: jaeger} } // Get returns a configmap specification for the current instance -func (u *UIConfig) Get() *v1.ConfigMap { +func (u *UIConfig) Get() *corev1.ConfigMap { // Check for empty map if u.jaeger.Spec.UI.Options.IsEmpty() { return nil @@ -37,7 +37,7 @@ func (u *UIConfig) Get() *v1.ConfigMap { "ui": string(json), } - return &v1.ConfigMap{ + return &corev1.ConfigMap{ TypeMeta: metav1.TypeMeta{ APIVersion: "v1", Kind: "ConfigMap", @@ -69,21 +69,21 @@ func (u *UIConfig) Get() *v1.ConfigMap { // Update will modify the supplied common spec and options to include // support for the UI configmap if appropriate -func Update(jaeger *v1alpha1.Jaeger, commonSpec *v1alpha1.JaegerCommonSpec, options *[]string) { +func Update(jaeger *v1.Jaeger, commonSpec *v1.JaegerCommonSpec, options *[]string) { // Check for empty map if jaeger.Spec.UI.Options.IsEmpty() { return } - volume := v1.Volume{ + volume := corev1.Volume{ Name: fmt.Sprintf("%s-ui-configuration-volume", jaeger.Name), - VolumeSource: v1.VolumeSource{ - ConfigMap: &v1.ConfigMapVolumeSource{ - LocalObjectReference: v1.LocalObjectReference{ + VolumeSource: corev1.VolumeSource{ + ConfigMap: &corev1.ConfigMapVolumeSource{ + LocalObjectReference: corev1.LocalObjectReference{ Name: fmt.Sprintf("%s-ui-configuration", jaeger.Name), }, - Items: []v1.KeyToPath{ - v1.KeyToPath{ + Items: []corev1.KeyToPath{ + corev1.KeyToPath{ Key: "ui", Path: "ui.json", }, @@ -91,7 +91,7 @@ func Update(jaeger *v1alpha1.Jaeger, commonSpec *v1alpha1.JaegerCommonSpec, opti }, }, } - volumeMount := v1.VolumeMount{ + volumeMount := corev1.VolumeMount{ Name: fmt.Sprintf("%s-ui-configuration-volume", jaeger.Name), MountPath: "/etc/config", ReadOnly: true, diff --git a/pkg/config/ui/ui_test.go b/pkg/config/ui/ui_test.go index e40e76309..b01c8aab3 100644 --- a/pkg/config/ui/ui_test.go +++ b/pkg/config/ui/ui_test.go @@ -5,11 +5,11 @@ import ( "github.com/stretchr/testify/assert" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestNoUIConfig(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestNoUIConfig") + jaeger := v1.NewJaeger("TestNoUIConfig") config := NewUIConfig(jaeger) dep := config.Get() @@ -17,8 +17,8 @@ func TestNoUIConfig(t *testing.T) { } func TestWithEmptyUIConfig(t *testing.T) { - uiconfig := v1alpha1.NewFreeForm(map[string]interface{}{}) - jaeger := v1alpha1.NewJaeger("TestWithEmptyUIConfig") + uiconfig := v1.NewFreeForm(map[string]interface{}{}) + jaeger := v1.NewJaeger("TestWithEmptyUIConfig") jaeger.Spec.UI.Options = uiconfig config := NewUIConfig(jaeger) @@ -27,13 +27,13 @@ func TestWithEmptyUIConfig(t *testing.T) { } func TestWithUIConfig(t *testing.T) { - uiconfig := v1alpha1.NewFreeForm(map[string]interface{}{ + uiconfig := v1.NewFreeForm(map[string]interface{}{ "tracking": map[string]interface{}{ "gaID": "UA-000000-2", }, }) json := `{"tracking":{"gaID":"UA-000000-2"}}` - jaeger := v1alpha1.NewJaeger("TestWithUIConfig") + jaeger := v1.NewJaeger("TestWithUIConfig") jaeger.Spec.UI.Options = uiconfig config := NewUIConfig(jaeger) @@ -42,9 +42,9 @@ func TestWithUIConfig(t *testing.T) { } func TestUpdateNoUIConfig(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestUpdateNoUIConfig") + jaeger := v1.NewJaeger("TestUpdateNoUIConfig") - commonSpec := v1alpha1.JaegerCommonSpec{} + commonSpec := v1.JaegerCommonSpec{} options := []string{} Update(jaeger, &commonSpec, &options) @@ -54,15 +54,15 @@ func TestUpdateNoUIConfig(t *testing.T) { } func TestUpdateWithUIConfig(t *testing.T) { - uiconfig := v1alpha1.NewFreeForm(map[string]interface{}{ + uiconfig := v1.NewFreeForm(map[string]interface{}{ "tracking": map[string]interface{}{ "gaID": "UA-000000-2", }, }) - jaeger := v1alpha1.NewJaeger("TestUpdateWithUIConfig") + jaeger := v1.NewJaeger("TestUpdateWithUIConfig") jaeger.Spec.UI.Options = uiconfig - commonSpec := v1alpha1.JaegerCommonSpec{} + commonSpec := v1.JaegerCommonSpec{} options := []string{} Update(jaeger, &commonSpec, &options) diff --git a/pkg/controller/add_legacy.go b/pkg/controller/add_legacy.go new file mode 100644 index 000000000..9486dd84d --- /dev/null +++ b/pkg/controller/add_legacy.go @@ -0,0 +1,10 @@ +package controller + +import ( + "github.com/jaegertracing/jaeger-operator/pkg/controller/legacy" +) + +func init() { + // AddToManagerFuncs is a list of functions to create controllers and add them to a manager. + AddToManagerFuncs = append(AddToManagerFuncs, legacy.Add) +} diff --git a/pkg/controller/deployment/deployment_controller.go b/pkg/controller/deployment/deployment_controller.go index 146bd99c4..9ed57c23a 100644 --- a/pkg/controller/deployment/deployment_controller.go +++ b/pkg/controller/deployment/deployment_controller.go @@ -14,7 +14,7 @@ import ( "sigs.k8s.io/controller-runtime/pkg/reconcile" "sigs.k8s.io/controller-runtime/pkg/source" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/inject" ) @@ -82,7 +82,7 @@ func (r *ReconcileDeployment) Reconcile(request reconcile.Request) (reconcile.Re } if inject.Needed(instance) { - pods := &v1alpha1.JaegerList{} + pods := &v1.JaegerList{} opts := &client.ListOptions{} err := r.client.List(context.Background(), opts, pods) if err != nil { diff --git a/pkg/controller/jaeger/account.go b/pkg/controller/jaeger/account.go index 6c6f2acff..001b4f6d1 100644 --- a/pkg/controller/jaeger/account.go +++ b/pkg/controller/jaeger/account.go @@ -3,19 +3,19 @@ package jaeger import ( "context" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" "sigs.k8s.io/controller-runtime/pkg/client" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/inventory" ) -func (r *ReconcileJaeger) applyAccounts(jaeger v1alpha1.Jaeger, desired []v1.ServiceAccount) error { +func (r *ReconcileJaeger) applyAccounts(jaeger v1.Jaeger, desired []corev1.ServiceAccount) error { opts := client.MatchingLabels(map[string]string{ "app.kubernetes.io/instance": jaeger.Name, "app.kubernetes.io/managed-by": "jaeger-operator", }) - list := &v1.ServiceAccountList{} + list := &corev1.ServiceAccountList{} if err := r.client.List(context.Background(), opts, list); err != nil { return err } diff --git a/pkg/controller/jaeger/account_test.go b/pkg/controller/jaeger/account_test.go index 51316bc44..384297b15 100644 --- a/pkg/controller/jaeger/account_test.go +++ b/pkg/controller/jaeger/account_test.go @@ -5,13 +5,13 @@ import ( "testing" "github.com/stretchr/testify/assert" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/reconcile" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/strategy" ) @@ -22,7 +22,7 @@ func TestServiceAccountCreate(t *testing.T) { } objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), } r, cl := getReconciler(objs) @@ -30,8 +30,8 @@ func TestServiceAccountCreate(t *testing.T) { NamespacedName: nsn, } - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { - s := strategy.New().WithAccounts([]v1.ServiceAccount{{ + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { + s := strategy.New().WithAccounts([]corev1.ServiceAccount{{ ObjectMeta: metav1.ObjectMeta{ Name: nsn.Name, }, @@ -46,7 +46,7 @@ func TestServiceAccountCreate(t *testing.T) { assert.NoError(t, err) assert.False(t, res.Requeue, "We don't requeue for now") - persisted := &v1.ServiceAccount{} + persisted := &corev1.ServiceAccount{} persistedName := types.NamespacedName{ Name: nsn.Name, Namespace: nsn.Namespace, @@ -62,22 +62,22 @@ func TestServiceAccountUpdate(t *testing.T) { Name: "TestServiceAccountUpdate", } - orig := v1.ServiceAccount{} + orig := corev1.ServiceAccount{} orig.Name = nsn.Name orig.Annotations = map[string]string{"key": "value"} objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { - updated := v1.ServiceAccount{} + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { + updated := corev1.ServiceAccount{} updated.Name = orig.Name updated.Annotations = map[string]string{"key": "new-value"} - s := strategy.New().WithAccounts([]v1.ServiceAccount{updated}) + s := strategy.New().WithAccounts([]corev1.ServiceAccount{updated}) return s } @@ -86,7 +86,7 @@ func TestServiceAccountUpdate(t *testing.T) { assert.NoError(t, err) // verify - persisted := &v1.ServiceAccount{} + persisted := &corev1.ServiceAccount{} persistedName := types.NamespacedName{ Name: orig.Name, Namespace: orig.Namespace, @@ -102,16 +102,16 @@ func TestServiceAccountDelete(t *testing.T) { Name: "TestServiceAccountDelete", } - orig := v1.ServiceAccount{} + orig := corev1.ServiceAccount{} orig.Name = nsn.Name objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { return strategy.S{} } @@ -120,7 +120,7 @@ func TestServiceAccountDelete(t *testing.T) { assert.NoError(t, err) // verify - persisted := &v1.ServiceAccount{} + persisted := &corev1.ServiceAccount{} persistedName := types.NamespacedName{ Name: orig.Name, Namespace: orig.Namespace, diff --git a/pkg/controller/jaeger/configmap.go b/pkg/controller/jaeger/configmap.go index d8bd23256..3cd68d7f4 100644 --- a/pkg/controller/jaeger/configmap.go +++ b/pkg/controller/jaeger/configmap.go @@ -3,19 +3,19 @@ package jaeger import ( "context" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" "sigs.k8s.io/controller-runtime/pkg/client" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/inventory" ) -func (r *ReconcileJaeger) applyConfigMaps(jaeger v1alpha1.Jaeger, desired []v1.ConfigMap) error { +func (r *ReconcileJaeger) applyConfigMaps(jaeger v1.Jaeger, desired []corev1.ConfigMap) error { opts := client.MatchingLabels(map[string]string{ "app.kubernetes.io/instance": jaeger.Name, "app.kubernetes.io/managed-by": "jaeger-operator", }) - list := &v1.ConfigMapList{} + list := &corev1.ConfigMapList{} if err := r.client.List(context.Background(), opts, list); err != nil { return err } diff --git a/pkg/controller/jaeger/configmap_test.go b/pkg/controller/jaeger/configmap_test.go index 85e62af86..9d94997d6 100644 --- a/pkg/controller/jaeger/configmap_test.go +++ b/pkg/controller/jaeger/configmap_test.go @@ -5,13 +5,13 @@ import ( "testing" "github.com/stretchr/testify/assert" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/reconcile" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/strategy" ) @@ -22,7 +22,7 @@ func TestConfigMapsCreate(t *testing.T) { } objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), } req := reconcile.Request{ @@ -30,8 +30,8 @@ func TestConfigMapsCreate(t *testing.T) { } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { - s := strategy.New().WithConfigMaps([]v1.ConfigMap{{ + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { + s := strategy.New().WithConfigMaps([]corev1.ConfigMap{{ ObjectMeta: metav1.ObjectMeta{ Name: nsn.Name, }, @@ -46,7 +46,7 @@ func TestConfigMapsCreate(t *testing.T) { assert.NoError(t, err) assert.False(t, res.Requeue, "We don't requeue for now") - persisted := &v1.ConfigMap{} + persisted := &corev1.ConfigMap{} persistedName := types.NamespacedName{ Name: nsn.Name, Namespace: nsn.Namespace, @@ -62,22 +62,22 @@ func TestConfigMapsUpdate(t *testing.T) { Name: "TestConfigMapsUpdate", } - orig := v1.ConfigMap{} + orig := corev1.ConfigMap{} orig.Name = nsn.Name orig.Annotations = map[string]string{"key": "value"} objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { - updated := v1.ConfigMap{} + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { + updated := corev1.ConfigMap{} updated.Name = orig.Name updated.Annotations = map[string]string{"key": "new-value"} - s := strategy.New().WithConfigMaps([]v1.ConfigMap{updated}) + s := strategy.New().WithConfigMaps([]corev1.ConfigMap{updated}) return s } @@ -86,7 +86,7 @@ func TestConfigMapsUpdate(t *testing.T) { assert.NoError(t, err) // verify - persisted := &v1.ConfigMap{} + persisted := &corev1.ConfigMap{} persistedName := types.NamespacedName{ Name: orig.Name, Namespace: orig.Namespace, @@ -102,16 +102,16 @@ func TestConfigMapsDelete(t *testing.T) { Name: "TestConfigMapsDelete", } - orig := v1.ConfigMap{} + orig := corev1.ConfigMap{} orig.Name = nsn.Name objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { return strategy.S{} } @@ -120,7 +120,7 @@ func TestConfigMapsDelete(t *testing.T) { assert.NoError(t, err) // verify - persisted := &v1.ConfigMap{} + persisted := &corev1.ConfigMap{} persistedName := types.NamespacedName{ Name: orig.Name, Namespace: orig.Namespace, diff --git a/pkg/controller/jaeger/cronjob.go b/pkg/controller/jaeger/cronjob.go index 1b9986fd5..a2aa6a1e3 100644 --- a/pkg/controller/jaeger/cronjob.go +++ b/pkg/controller/jaeger/cronjob.go @@ -6,11 +6,11 @@ import ( batchv1beta1 "k8s.io/api/batch/v1beta1" "sigs.k8s.io/controller-runtime/pkg/client" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/inventory" ) -func (r *ReconcileJaeger) applyCronJobs(jaeger v1alpha1.Jaeger, desired []batchv1beta1.CronJob) error { +func (r *ReconcileJaeger) applyCronJobs(jaeger v1.Jaeger, desired []batchv1beta1.CronJob) error { opts := client.MatchingLabels(map[string]string{ "app.kubernetes.io/instance": jaeger.Name, "app.kubernetes.io/managed-by": "jaeger-operator", diff --git a/pkg/controller/jaeger/cronjob_test.go b/pkg/controller/jaeger/cronjob_test.go index 5f2665329..ebf5e3775 100644 --- a/pkg/controller/jaeger/cronjob_test.go +++ b/pkg/controller/jaeger/cronjob_test.go @@ -11,7 +11,7 @@ import ( "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/reconcile" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/strategy" ) @@ -22,7 +22,7 @@ func TestCronJobsCreate(t *testing.T) { } objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), } req := reconcile.Request{ @@ -30,7 +30,7 @@ func TestCronJobsCreate(t *testing.T) { } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { s := strategy.New().WithCronJobs([]batchv1beta1.CronJob{{ ObjectMeta: metav1.ObjectMeta{ Name: nsn.Name, @@ -67,12 +67,12 @@ func TestCronJobsUpdate(t *testing.T) { orig.Annotations = map[string]string{"key": "value"} objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { updated := batchv1beta1.CronJob{} updated.Name = orig.Name updated.Annotations = map[string]string{"key": "new-value"} @@ -106,12 +106,12 @@ func TestCronJobsDelete(t *testing.T) { orig.Name = nsn.Name objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { return strategy.S{} } diff --git a/pkg/controller/jaeger/daemonset.go b/pkg/controller/jaeger/daemonset.go index 41f71cd8b..f85c75f51 100644 --- a/pkg/controller/jaeger/daemonset.go +++ b/pkg/controller/jaeger/daemonset.go @@ -6,11 +6,11 @@ import ( appsv1 "k8s.io/api/apps/v1" "sigs.k8s.io/controller-runtime/pkg/client" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/inventory" ) -func (r *ReconcileJaeger) applyDaemonSets(jaeger v1alpha1.Jaeger, desired []appsv1.DaemonSet) error { +func (r *ReconcileJaeger) applyDaemonSets(jaeger v1.Jaeger, desired []appsv1.DaemonSet) error { opts := client.MatchingLabels(map[string]string{ "app.kubernetes.io/instance": jaeger.Name, "app.kubernetes.io/managed-by": "jaeger-operator", diff --git a/pkg/controller/jaeger/daemonset_test.go b/pkg/controller/jaeger/daemonset_test.go index cd81c2de0..3c883977f 100644 --- a/pkg/controller/jaeger/daemonset_test.go +++ b/pkg/controller/jaeger/daemonset_test.go @@ -11,7 +11,7 @@ import ( "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/reconcile" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/strategy" ) @@ -22,7 +22,7 @@ func TestDaemonSetsCreate(t *testing.T) { } objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), } req := reconcile.Request{ @@ -30,7 +30,7 @@ func TestDaemonSetsCreate(t *testing.T) { } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { s := strategy.New().WithDaemonSets([]appsv1.DaemonSet{{ ObjectMeta: metav1.ObjectMeta{ Name: nsn.Name, @@ -67,12 +67,12 @@ func TestDaemonSetsUpdate(t *testing.T) { orig.Annotations = map[string]string{"key": "value"} objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { updated := appsv1.DaemonSet{} updated.Name = orig.Name updated.Annotations = map[string]string{"key": "new-value"} @@ -106,12 +106,12 @@ func TestDaemonSetsDelete(t *testing.T) { orig.Name = nsn.Name objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { return strategy.S{} } diff --git a/pkg/controller/jaeger/dependencies_test.go b/pkg/controller/jaeger/dependencies_test.go index 054bdb84f..5066c15f2 100644 --- a/pkg/controller/jaeger/dependencies_test.go +++ b/pkg/controller/jaeger/dependencies_test.go @@ -12,7 +12,7 @@ import ( "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/reconcile" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/strategy" ) @@ -22,13 +22,13 @@ func TestHandleDependencies(t *testing.T) { Name: "TestHandleDependencies", } - objs := []runtime.Object{v1alpha1.NewJaeger(nsn.Name)} + objs := []runtime.Object{v1.NewJaeger(nsn.Name)} dep := batchv1.Job{} dep.Name = nsn.Name r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { s := strategy.New().WithDependencies([]batchv1.Job{dep}) return s } diff --git a/pkg/controller/jaeger/deployment.go b/pkg/controller/jaeger/deployment.go index cac7012f9..d41e65dd2 100644 --- a/pkg/controller/jaeger/deployment.go +++ b/pkg/controller/jaeger/deployment.go @@ -10,11 +10,11 @@ import ( "k8s.io/apimachinery/pkg/util/wait" "sigs.k8s.io/controller-runtime/pkg/client" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/inventory" ) -func (r *ReconcileJaeger) applyDeployments(jaeger v1alpha1.Jaeger, desired []appsv1.Deployment) error { +func (r *ReconcileJaeger) applyDeployments(jaeger v1.Jaeger, desired []appsv1.Deployment) error { opts := client.MatchingLabels(map[string]string{ "app.kubernetes.io/instance": jaeger.Name, "app.kubernetes.io/managed-by": "jaeger-operator", diff --git a/pkg/controller/jaeger/deployment_test.go b/pkg/controller/jaeger/deployment_test.go index 1dce30799..76dade689 100644 --- a/pkg/controller/jaeger/deployment_test.go +++ b/pkg/controller/jaeger/deployment_test.go @@ -13,7 +13,7 @@ import ( "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/reconcile" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/strategy" ) @@ -24,7 +24,7 @@ func TestDeploymentCreate(t *testing.T) { } objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), } req := reconcile.Request{ @@ -32,7 +32,7 @@ func TestDeploymentCreate(t *testing.T) { } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { s := strategy.New().WithDeployments([]appsv1.Deployment{{ ObjectMeta: metav1.ObjectMeta{ Name: nsn.Name, @@ -69,12 +69,12 @@ func TestDeploymentUpdate(t *testing.T) { depOriginal.Annotations = map[string]string{"key": "value"} objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &depOriginal, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { depUpdated := appsv1.Deployment{} depUpdated.Name = depOriginal.Name depUpdated.Annotations = map[string]string{"key": "new-value"} @@ -108,12 +108,12 @@ func TestDeploymentDelete(t *testing.T) { depOriginal.Name = nsn.Name objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &depOriginal, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { return strategy.S{} } @@ -145,7 +145,7 @@ func TestDeploymentDeleteAfterCreate(t *testing.T) { "app.kubernetes.io/instance": nsn.Name, "app.kubernetes.io/managed-by": "jaeger-operator", } - objs := []runtime.Object{v1alpha1.NewJaeger(nsn.Name), &depToDelete} + objs := []runtime.Object{v1.NewJaeger(nsn.Name), &depToDelete} // the deployment to be created dep := appsv1.Deployment{} @@ -154,7 +154,7 @@ func TestDeploymentDeleteAfterCreate(t *testing.T) { dep.Status.ReadyReplicas = 1 r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { s := strategy.New().WithDeployments([]appsv1.Deployment{dep}) return s } diff --git a/pkg/controller/jaeger/elasticsearch.go b/pkg/controller/jaeger/elasticsearch.go index 5b1112646..e096b4991 100644 --- a/pkg/controller/jaeger/elasticsearch.go +++ b/pkg/controller/jaeger/elasticsearch.go @@ -6,16 +6,16 @@ import ( "github.com/pkg/errors" "github.com/sirupsen/logrus" - "k8s.io/api/apps/v1" + corev1 "k8s.io/api/apps/v1" "k8s.io/apimachinery/pkg/util/wait" "sigs.k8s.io/controller-runtime/pkg/client" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/inventory" esv1alpha1 "github.com/jaegertracing/jaeger-operator/pkg/storage/elasticsearch/v1alpha1" ) -func (r *ReconcileJaeger) applyElasticsearches(jaeger v1alpha1.Jaeger, desired []esv1alpha1.Elasticsearch) error { +func (r *ReconcileJaeger) applyElasticsearches(jaeger v1.Jaeger, desired []esv1alpha1.Elasticsearch) error { opts := client.MatchingLabels(map[string]string{ "app.kubernetes.io/instance": jaeger.Name, "app.kubernetes.io/part-of": "jaeger", @@ -59,7 +59,7 @@ func waitForAvailableElastic(c client.Client, es esv1alpha1.Elasticsearch) error expectedSize += n.NodeCount } return wait.PollImmediate(time.Second, 2*time.Minute, func() (done bool, err error) { - depList := v1.DeploymentList{} + depList := corev1.DeploymentList{} if err = c.List(context.Background(), client.MatchingLabels(es.Labels).InNamespace(es.Namespace), &depList); err != nil { return false, err } @@ -77,5 +77,4 @@ func waitForAvailableElastic(c client.Client, es esv1alpha1.Elasticsearch) error }).Debug("Waiting for Elasticsearch to be available") return available == expectedSize, nil }) - return nil } diff --git a/pkg/controller/jaeger/elasticsearch_test.go b/pkg/controller/jaeger/elasticsearch_test.go index bd696f624..2abf87ec4 100644 --- a/pkg/controller/jaeger/elasticsearch_test.go +++ b/pkg/controller/jaeger/elasticsearch_test.go @@ -11,13 +11,13 @@ import ( "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/reconcile" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" esv1alpha1 "github.com/jaegertracing/jaeger-operator/pkg/storage/elasticsearch/v1alpha1" "github.com/jaegertracing/jaeger-operator/pkg/strategy" ) func TestElasticsearchesCreate(t *testing.T) { - viper.Set("es-provision", v1alpha1.FlagProvisionElasticsearchTrue) + viper.Set("es-provision", v1.FlagProvisionElasticsearchTrue) defer viper.Reset() // prepare @@ -26,7 +26,7 @@ func TestElasticsearchesCreate(t *testing.T) { } objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), } req := reconcile.Request{ @@ -34,7 +34,7 @@ func TestElasticsearchesCreate(t *testing.T) { } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { s := strategy.New().WithElasticsearches([]esv1alpha1.Elasticsearch{{ ObjectMeta: metav1.ObjectMeta{ Name: nsn.Name, @@ -61,7 +61,7 @@ func TestElasticsearchesCreate(t *testing.T) { } func TestElasticsearchesUpdate(t *testing.T) { - viper.Set("es-provision", v1alpha1.FlagProvisionElasticsearchTrue) + viper.Set("es-provision", v1.FlagProvisionElasticsearchTrue) defer viper.Reset() // prepare @@ -74,12 +74,12 @@ func TestElasticsearchesUpdate(t *testing.T) { orig.Annotations = map[string]string{"key": "value"} objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { updated := esv1alpha1.Elasticsearch{} updated.Name = orig.Name updated.Annotations = map[string]string{"key": "new-value"} @@ -104,7 +104,7 @@ func TestElasticsearchesUpdate(t *testing.T) { } func TestElasticsearchesDelete(t *testing.T) { - viper.Set("es-provision", v1alpha1.FlagProvisionElasticsearchTrue) + viper.Set("es-provision", v1.FlagProvisionElasticsearchTrue) defer viper.Reset() // prepare @@ -116,12 +116,12 @@ func TestElasticsearchesDelete(t *testing.T) { orig.Name = nsn.Name objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { return strategy.S{} } diff --git a/pkg/controller/jaeger/ingress.go b/pkg/controller/jaeger/ingress.go index ad0f78253..6a2521a3b 100644 --- a/pkg/controller/jaeger/ingress.go +++ b/pkg/controller/jaeger/ingress.go @@ -6,11 +6,11 @@ import ( "k8s.io/api/extensions/v1beta1" "sigs.k8s.io/controller-runtime/pkg/client" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/inventory" ) -func (r *ReconcileJaeger) applyIngresses(jaeger v1alpha1.Jaeger, desired []v1beta1.Ingress) error { +func (r *ReconcileJaeger) applyIngresses(jaeger v1.Jaeger, desired []v1beta1.Ingress) error { opts := client.MatchingLabels(map[string]string{ "app.kubernetes.io/instance": jaeger.Name, "app.kubernetes.io/managed-by": "jaeger-operator", diff --git a/pkg/controller/jaeger/ingress_test.go b/pkg/controller/jaeger/ingress_test.go index 310519e4d..0e46eaed8 100644 --- a/pkg/controller/jaeger/ingress_test.go +++ b/pkg/controller/jaeger/ingress_test.go @@ -11,7 +11,7 @@ import ( "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/reconcile" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/strategy" ) @@ -22,7 +22,7 @@ func TestIngressesCreate(t *testing.T) { } objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), } req := reconcile.Request{ @@ -30,7 +30,7 @@ func TestIngressesCreate(t *testing.T) { } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { s := strategy.New().WithIngresses([]v1beta1.Ingress{{ ObjectMeta: metav1.ObjectMeta{ Name: nsn.Name, @@ -67,12 +67,12 @@ func TestIngressesUpdate(t *testing.T) { orig.Annotations = map[string]string{"key": "value"} objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { updated := v1beta1.Ingress{} updated.Name = orig.Name updated.Annotations = map[string]string{"key": "new-value"} @@ -106,12 +106,12 @@ func TestIngressesDelete(t *testing.T) { orig.Name = nsn.Name objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { return strategy.S{} } diff --git a/pkg/controller/jaeger/jaeger_controller.go b/pkg/controller/jaeger/jaeger_controller.go index 468a8fca2..21e46273b 100644 --- a/pkg/controller/jaeger/jaeger_controller.go +++ b/pkg/controller/jaeger/jaeger_controller.go @@ -18,7 +18,7 @@ import ( "sigs.k8s.io/controller-runtime/pkg/reconcile" "sigs.k8s.io/controller-runtime/pkg/source" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/controller/jaeger/status" "github.com/jaegertracing/jaeger-operator/pkg/strategy" ) @@ -43,7 +43,7 @@ func add(mgr manager.Manager, r reconcile.Reconciler) error { } // Watch for changes to primary resource Jaeger - err = c.Watch(&source.Kind{Type: &v1alpha1.Jaeger{}}, &handler.EnqueueRequestForObject{}) + err = c.Watch(&source.Kind{Type: &v1.Jaeger{}}, &handler.EnqueueRequestForObject{}) if err != nil { return err } @@ -59,7 +59,7 @@ type ReconcileJaeger struct { // that reads objects from the cache and writes to the apiserver client client.Client scheme *runtime.Scheme - strategyChooser func(*v1alpha1.Jaeger) strategy.S + strategyChooser func(*v1.Jaeger) strategy.S } // Reconcile reads that state of the cluster for a Jaeger object and makes changes based on the state read @@ -77,7 +77,7 @@ func (r *ReconcileJaeger) Reconcile(request reconcile.Request) (reconcile.Result }).Debug("Reconciling Jaeger") // Fetch the Jaeger instance - instance := &v1alpha1.Jaeger{} + instance := &v1.Jaeger{} err := r.client.Get(context.Background(), request.NamespacedName, instance) if err != nil { if errors.IsNotFound(err) { @@ -93,7 +93,7 @@ func (r *ReconcileJaeger) Reconcile(request reconcile.Request) (reconcile.Result // workaround for https://github.com/kubernetes-sigs/controller-runtime/issues/202 // see also: https://github.com/kubernetes-sigs/controller-runtime/pull/212 // once there's a version incorporating the PR above, the manual setting of the GKV can be removed - instance.APIVersion = fmt.Sprintf("%s/%s", v1alpha1.SchemeGroupVersion.Group, v1alpha1.SchemeGroupVersion.Version) + instance.APIVersion = fmt.Sprintf("%s/%s", v1.SchemeGroupVersion.Group, v1.SchemeGroupVersion.Version) instance.Kind = "Jaeger" originalInstance := *instance @@ -126,7 +126,7 @@ func (r *ReconcileJaeger) Reconcile(request reconcile.Request) (reconcile.Result return reconcile.Result{RequeueAfter: 5 * time.Second}, nil } -func (r *ReconcileJaeger) runStrategyChooser(instance *v1alpha1.Jaeger) strategy.S { +func (r *ReconcileJaeger) runStrategyChooser(instance *v1.Jaeger) strategy.S { if nil == r.strategyChooser { return defaultStrategyChooser(instance) } @@ -134,18 +134,18 @@ func (r *ReconcileJaeger) runStrategyChooser(instance *v1alpha1.Jaeger) strategy return r.strategyChooser(instance) } -func defaultStrategyChooser(instance *v1alpha1.Jaeger) strategy.S { +func defaultStrategyChooser(instance *v1.Jaeger) strategy.S { return strategy.For(context.Background(), instance) } -func (r *ReconcileJaeger) apply(jaeger v1alpha1.Jaeger, str strategy.S) error { +func (r *ReconcileJaeger) apply(jaeger v1.Jaeger, str strategy.S) error { // secrets have to be created before ES - they are mounted to the ES pod if err := r.applySecrets(jaeger, str.Secrets()); err != nil { return err } elasticsearches := str.Elasticsearches() - if strings.EqualFold(viper.GetString("es-provision"), v1alpha1.FlagProvisionElasticsearchTrue) { + if strings.EqualFold(viper.GetString("es-provision"), v1.FlagProvisionElasticsearchTrue) { if err := r.applyElasticsearches(jaeger, elasticsearches); err != nil { return err } @@ -191,7 +191,7 @@ func (r *ReconcileJaeger) apply(jaeger v1alpha1.Jaeger, str strategy.S) error { return err } - if strings.EqualFold(viper.GetString("platform"), v1alpha1.FlagPlatformOpenShift) { + if strings.EqualFold(viper.GetString("platform"), v1.FlagPlatformOpenShift) { if err := r.applyRoutes(jaeger, str.Routes()); err != nil { return err } diff --git a/pkg/controller/jaeger/jaeger_controller_test.go b/pkg/controller/jaeger/jaeger_controller_test.go index 623bf8e37..ce9dd2aa1 100644 --- a/pkg/controller/jaeger/jaeger_controller_test.go +++ b/pkg/controller/jaeger/jaeger_controller_test.go @@ -13,7 +13,7 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client/fake" "sigs.k8s.io/controller-runtime/pkg/reconcile" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" esv1alpha1 "github.com/jaegertracing/jaeger-operator/pkg/storage/elasticsearch/v1alpha1" "github.com/jaegertracing/jaeger-operator/pkg/strategy" ) @@ -25,7 +25,7 @@ func TestNewJaegerInstance(t *testing.T) { } objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), } req := reconcile.Request{ @@ -33,7 +33,7 @@ func TestNewJaegerInstance(t *testing.T) { } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { jaeger.Spec.Strategy = "custom-strategy" return strategy.S{} } @@ -45,7 +45,7 @@ func TestNewJaegerInstance(t *testing.T) { assert.NoError(t, err) assert.False(t, res.Requeue, "We don't requeue for now") - persisted := &v1alpha1.Jaeger{} + persisted := &v1.Jaeger{} err = cl.Get(context.Background(), req.NamespacedName, persisted) assert.Equal(t, persisted.Name, nsn.Name) assert.NoError(t, err) @@ -61,9 +61,9 @@ func TestDeletedInstance(t *testing.T) { // we should just not fail, as there won't be anything to do // all our objects should have an OwnerReference, so that when the jaeger object is deleted, the owned objects are deleted as well - jaeger := v1alpha1.NewJaeger("TestDeletedInstance") + jaeger := v1.NewJaeger("TestDeletedInstance") s := scheme.Scheme - s.AddKnownTypes(v1alpha1.SchemeGroupVersion, jaeger) + s.AddKnownTypes(v1.SchemeGroupVersion, jaeger) // no known objects cl := fake.NewFakeClient() @@ -83,7 +83,7 @@ func TestDeletedInstance(t *testing.T) { assert.NoError(t, err) assert.False(t, res.Requeue, "We don't requeue for now") - persisted := &v1alpha1.Jaeger{} + persisted := &v1.Jaeger{} err = cl.Get(context.Background(), req.NamespacedName, persisted) assert.NotEmpty(t, jaeger.Name) assert.Empty(t, persisted.Name) // this means that the object wasn't found @@ -96,10 +96,10 @@ func getReconciler(objs []runtime.Object) (*ReconcileJaeger, client.Client) { osv1.Install(s) // Jaeger - s.AddKnownTypes(v1alpha1.SchemeGroupVersion, &v1alpha1.Jaeger{}) + s.AddKnownTypes(v1.SchemeGroupVersion, &v1.Jaeger{}) // Jaeger's Elasticsearch - s.AddKnownTypes(v1alpha1.SchemeGroupVersion, &esv1alpha1.Elasticsearch{}, &esv1alpha1.ElasticsearchList{}) + s.AddKnownTypes(v1.SchemeGroupVersion, &esv1alpha1.Elasticsearch{}, &esv1alpha1.ElasticsearchList{}) cl := fake.NewFakeClient(objs...) return &ReconcileJaeger{client: cl, scheme: s}, cl diff --git a/pkg/controller/jaeger/role.go b/pkg/controller/jaeger/role.go index 6ed5c40d7..286ab344e 100644 --- a/pkg/controller/jaeger/role.go +++ b/pkg/controller/jaeger/role.go @@ -6,11 +6,11 @@ import ( rbacv1 "k8s.io/api/rbac/v1" "sigs.k8s.io/controller-runtime/pkg/client" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/inventory" ) -func (r *ReconcileJaeger) applyRoles(jaeger v1alpha1.Jaeger, desired []rbacv1.Role) error { +func (r *ReconcileJaeger) applyRoles(jaeger v1.Jaeger, desired []rbacv1.Role) error { opts := client.MatchingLabels(map[string]string{ "app.kubernetes.io/instance": jaeger.Name, "app.kubernetes.io/managed-by": "jaeger-operator", diff --git a/pkg/controller/jaeger/role_test.go b/pkg/controller/jaeger/role_test.go index 6c4beec66..9999ca7ee 100644 --- a/pkg/controller/jaeger/role_test.go +++ b/pkg/controller/jaeger/role_test.go @@ -11,7 +11,7 @@ import ( "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/reconcile" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/strategy" ) @@ -22,7 +22,7 @@ func TestRoleCreate(t *testing.T) { } objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), } r, cl := getReconciler(objs) @@ -30,7 +30,7 @@ func TestRoleCreate(t *testing.T) { NamespacedName: nsn, } - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { s := strategy.New().WithRoles([]rbacv1.Role{{ ObjectMeta: metav1.ObjectMeta{ Name: nsn.Name, @@ -67,12 +67,12 @@ func TestRoleUpdate(t *testing.T) { orig.Annotations = map[string]string{"key": "value"} objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { updated := rbacv1.Role{} updated.Name = orig.Name updated.Annotations = map[string]string{"key": "new-value"} @@ -106,12 +106,12 @@ func TestRoleDelete(t *testing.T) { orig.Name = nsn.Name objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { return strategy.S{} } diff --git a/pkg/controller/jaeger/rolebinding.go b/pkg/controller/jaeger/rolebinding.go index bb01af422..c2ef8202c 100644 --- a/pkg/controller/jaeger/rolebinding.go +++ b/pkg/controller/jaeger/rolebinding.go @@ -6,11 +6,11 @@ import ( rbacv1 "k8s.io/api/rbac/v1" "sigs.k8s.io/controller-runtime/pkg/client" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/inventory" ) -func (r *ReconcileJaeger) applyRoleBindings(jaeger v1alpha1.Jaeger, desired []rbacv1.RoleBinding) error { +func (r *ReconcileJaeger) applyRoleBindings(jaeger v1.Jaeger, desired []rbacv1.RoleBinding) error { opts := client.MatchingLabels(map[string]string{ "app.kubernetes.io/instance": jaeger.Name, "app.kubernetes.io/managed-by": "jaeger-operator", diff --git a/pkg/controller/jaeger/rolebinding_test.go b/pkg/controller/jaeger/rolebinding_test.go index df88ca8cb..d04c09843 100644 --- a/pkg/controller/jaeger/rolebinding_test.go +++ b/pkg/controller/jaeger/rolebinding_test.go @@ -11,7 +11,7 @@ import ( "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/reconcile" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/strategy" ) @@ -22,7 +22,7 @@ func TestRoleBindingCreate(t *testing.T) { } objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), } r, cl := getReconciler(objs) @@ -30,7 +30,7 @@ func TestRoleBindingCreate(t *testing.T) { NamespacedName: nsn, } - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { s := strategy.New().WithRoleBindings([]rbacv1.RoleBinding{{ ObjectMeta: metav1.ObjectMeta{ Name: nsn.Name, @@ -67,12 +67,12 @@ func TestRoleBindingUpdate(t *testing.T) { orig.Annotations = map[string]string{"key": "value"} objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { updated := rbacv1.RoleBinding{} updated.Name = orig.Name updated.Annotations = map[string]string{"key": "new-value"} @@ -106,12 +106,12 @@ func TestRoleBindingDelete(t *testing.T) { orig.Name = nsn.Name objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { return strategy.S{} } diff --git a/pkg/controller/jaeger/route.go b/pkg/controller/jaeger/route.go index afca11da5..fb2fea64b 100644 --- a/pkg/controller/jaeger/route.go +++ b/pkg/controller/jaeger/route.go @@ -6,11 +6,11 @@ import ( osv1 "github.com/openshift/api/route/v1" "sigs.k8s.io/controller-runtime/pkg/client" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/inventory" ) -func (r *ReconcileJaeger) applyRoutes(jaeger v1alpha1.Jaeger, desired []osv1.Route) error { +func (r *ReconcileJaeger) applyRoutes(jaeger v1.Jaeger, desired []osv1.Route) error { opts := client.MatchingLabels(map[string]string{ "app.kubernetes.io/instance": jaeger.Name, "app.kubernetes.io/managed-by": "jaeger-operator", diff --git a/pkg/controller/jaeger/route_test.go b/pkg/controller/jaeger/route_test.go index d01ee993f..90bb793c2 100644 --- a/pkg/controller/jaeger/route_test.go +++ b/pkg/controller/jaeger/route_test.go @@ -12,7 +12,7 @@ import ( "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/reconcile" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/strategy" ) @@ -26,7 +26,7 @@ func TestRoutesCreate(t *testing.T) { } objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), } req := reconcile.Request{ @@ -34,7 +34,7 @@ func TestRoutesCreate(t *testing.T) { } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { s := strategy.New().WithRoutes([]osv1.Route{{ ObjectMeta: metav1.ObjectMeta{ Name: nsn.Name, @@ -74,12 +74,12 @@ func TestRoutesUpdate(t *testing.T) { orig.Annotations = map[string]string{"key": "value"} objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { updated := osv1.Route{} updated.Name = orig.Name updated.Annotations = map[string]string{"key": "new-value"} @@ -116,12 +116,12 @@ func TestRoutesDelete(t *testing.T) { orig.Name = nsn.Name objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { return strategy.S{} } diff --git a/pkg/controller/jaeger/secret.go b/pkg/controller/jaeger/secret.go index 3bef87c2c..0364d64fa 100644 --- a/pkg/controller/jaeger/secret.go +++ b/pkg/controller/jaeger/secret.go @@ -3,19 +3,19 @@ package jaeger import ( "context" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" "sigs.k8s.io/controller-runtime/pkg/client" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/inventory" ) -func (r *ReconcileJaeger) applySecrets(jaeger v1alpha1.Jaeger, desired []v1.Secret) error { +func (r *ReconcileJaeger) applySecrets(jaeger v1.Jaeger, desired []corev1.Secret) error { opts := client.MatchingLabels(map[string]string{ "app.kubernetes.io/instance": jaeger.Name, "app.kubernetes.io/managed-by": "jaeger-operator", }) - list := &v1.SecretList{} + list := &corev1.SecretList{} if err := r.client.List(context.Background(), opts, list); err != nil { return err } diff --git a/pkg/controller/jaeger/secret_test.go b/pkg/controller/jaeger/secret_test.go index 2a9893ca7..20f0d1597 100644 --- a/pkg/controller/jaeger/secret_test.go +++ b/pkg/controller/jaeger/secret_test.go @@ -5,13 +5,13 @@ import ( "testing" "github.com/stretchr/testify/assert" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/reconcile" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/strategy" ) @@ -22,7 +22,7 @@ func TestSecretsCreate(t *testing.T) { } objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), } req := reconcile.Request{ @@ -30,8 +30,8 @@ func TestSecretsCreate(t *testing.T) { } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { - s := strategy.New().WithSecrets([]v1.Secret{{ + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { + s := strategy.New().WithSecrets([]corev1.Secret{{ ObjectMeta: metav1.ObjectMeta{ Name: nsn.Name, }, @@ -46,7 +46,7 @@ func TestSecretsCreate(t *testing.T) { assert.NoError(t, err) assert.False(t, res.Requeue, "We don't requeue for now") - persisted := &v1.Secret{} + persisted := &corev1.Secret{} persistedName := types.NamespacedName{ Name: nsn.Name, Namespace: nsn.Namespace, @@ -62,22 +62,22 @@ func TestSecretsUpdate(t *testing.T) { Name: "TestSecretsUpdate", } - orig := v1.Secret{} + orig := corev1.Secret{} orig.Name = nsn.Name orig.Annotations = map[string]string{"key": "value"} objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { - updated := v1.Secret{} + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { + updated := corev1.Secret{} updated.Name = orig.Name updated.Annotations = map[string]string{"key": "new-value"} - s := strategy.New().WithSecrets([]v1.Secret{updated}) + s := strategy.New().WithSecrets([]corev1.Secret{updated}) return s } @@ -86,7 +86,7 @@ func TestSecretsUpdate(t *testing.T) { assert.NoError(t, err) // verify - persisted := &v1.Secret{} + persisted := &corev1.Secret{} persistedName := types.NamespacedName{ Name: orig.Name, Namespace: orig.Namespace, @@ -102,16 +102,16 @@ func TestSecretsDelete(t *testing.T) { Name: "TestSecretsDelete", } - orig := v1.Secret{} + orig := corev1.Secret{} orig.Name = nsn.Name objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { return strategy.S{} } @@ -120,7 +120,7 @@ func TestSecretsDelete(t *testing.T) { assert.NoError(t, err) // verify - persisted := &v1.Secret{} + persisted := &corev1.Secret{} persistedName := types.NamespacedName{ Name: orig.Name, Namespace: orig.Namespace, diff --git a/pkg/controller/jaeger/service.go b/pkg/controller/jaeger/service.go index b51b093d6..df07e0d34 100644 --- a/pkg/controller/jaeger/service.go +++ b/pkg/controller/jaeger/service.go @@ -3,19 +3,19 @@ package jaeger import ( "context" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" "sigs.k8s.io/controller-runtime/pkg/client" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/inventory" ) -func (r *ReconcileJaeger) applyServices(jaeger v1alpha1.Jaeger, desired []v1.Service) error { +func (r *ReconcileJaeger) applyServices(jaeger v1.Jaeger, desired []corev1.Service) error { opts := client.MatchingLabels(map[string]string{ "app.kubernetes.io/instance": jaeger.Name, "app.kubernetes.io/managed-by": "jaeger-operator", }) - list := &v1.ServiceList{} + list := &corev1.ServiceList{} if err := r.client.List(context.Background(), opts, list); err != nil { return err } diff --git a/pkg/controller/jaeger/service_test.go b/pkg/controller/jaeger/service_test.go index aa0bbc2cf..e09f7ec8f 100644 --- a/pkg/controller/jaeger/service_test.go +++ b/pkg/controller/jaeger/service_test.go @@ -5,13 +5,13 @@ import ( "testing" "github.com/stretchr/testify/assert" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/controller-runtime/pkg/reconcile" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/strategy" ) @@ -22,7 +22,7 @@ func TestServicesCreate(t *testing.T) { } objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), } req := reconcile.Request{ @@ -30,8 +30,8 @@ func TestServicesCreate(t *testing.T) { } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { - s := strategy.New().WithServices([]v1.Service{{ + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { + s := strategy.New().WithServices([]corev1.Service{{ ObjectMeta: metav1.ObjectMeta{ Name: nsn.Name, }, @@ -46,7 +46,7 @@ func TestServicesCreate(t *testing.T) { assert.NoError(t, err) assert.False(t, res.Requeue, "We don't requeue for now") - persisted := &v1.Service{} + persisted := &corev1.Service{} persistedName := types.NamespacedName{ Name: nsn.Name, Namespace: nsn.Namespace, @@ -62,22 +62,22 @@ func TestServicesUpdate(t *testing.T) { Name: "TestServicesUpdate", } - orig := v1.Service{} + orig := corev1.Service{} orig.Name = nsn.Name orig.Annotations = map[string]string{"key": "value"} objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { - updated := v1.Service{} + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { + updated := corev1.Service{} updated.Name = orig.Name updated.Annotations = map[string]string{"key": "new-value"} - s := strategy.New().WithServices([]v1.Service{updated}) + s := strategy.New().WithServices([]corev1.Service{updated}) return s } @@ -86,7 +86,7 @@ func TestServicesUpdate(t *testing.T) { assert.NoError(t, err) // verify - persisted := &v1.Service{} + persisted := &corev1.Service{} persistedName := types.NamespacedName{ Name: orig.Name, Namespace: orig.Namespace, @@ -102,16 +102,16 @@ func TestServicesDelete(t *testing.T) { Name: "TestServicesDelete", } - orig := v1.Service{} + orig := corev1.Service{} orig.Name = nsn.Name objs := []runtime.Object{ - v1alpha1.NewJaeger(nsn.Name), + v1.NewJaeger(nsn.Name), &orig, } r, cl := getReconciler(objs) - r.strategyChooser = func(jaeger *v1alpha1.Jaeger) strategy.S { + r.strategyChooser = func(jaeger *v1.Jaeger) strategy.S { return strategy.S{} } @@ -120,7 +120,7 @@ func TestServicesDelete(t *testing.T) { assert.NoError(t, err) // verify - persisted := &v1.Service{} + persisted := &corev1.Service{} persistedName := types.NamespacedName{ Name: orig.Name, Namespace: orig.Namespace, diff --git a/pkg/controller/jaeger/status/collector.go b/pkg/controller/jaeger/status/collector.go index 4fd9039ab..7632160d2 100644 --- a/pkg/controller/jaeger/status/collector.go +++ b/pkg/controller/jaeger/status/collector.go @@ -10,10 +10,10 @@ import ( "time" log "github.com/sirupsen/logrus" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" "sigs.k8s.io/controller-runtime/pkg/client" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) type scraper struct { @@ -27,14 +27,14 @@ func withClient(c client.Client) scraper { } // Scrape fills a JaegerStatus object with the current state of all Jaeger pods (currently only collectors) -func Scrape(c client.Client, jaeger v1alpha1.Jaeger) v1alpha1.Jaeger { +func Scrape(c client.Client, jaeger v1.Jaeger) v1.Jaeger { s := withClient(c) return s.scrape(jaeger) } -func (s *scraper) scrape(jaeger v1alpha1.Jaeger) v1alpha1.Jaeger { +func (s *scraper) scrape(jaeger v1.Jaeger) v1.Jaeger { // reset the status object - jaeger.Status = v1alpha1.JaegerStatus{} + jaeger.Status = v1.JaegerStatus{} if strings.EqualFold(jaeger.Spec.Strategy, "allinone") { return s.allInOnePodsState(jaeger) @@ -43,7 +43,7 @@ func (s *scraper) scrape(jaeger v1alpha1.Jaeger) v1alpha1.Jaeger { return s.collectorPodsState(jaeger) } -func (s *scraper) allInOnePodsState(jaeger v1alpha1.Jaeger) v1alpha1.Jaeger { +func (s *scraper) allInOnePodsState(jaeger v1.Jaeger) v1.Jaeger { if s.targetPort == 0 { s.targetPort = 16686 } @@ -57,7 +57,7 @@ func (s *scraper) allInOnePodsState(jaeger v1alpha1.Jaeger) v1alpha1.Jaeger { return s.matchingPodsState(jaeger, opts) } -func (s *scraper) collectorPodsState(jaeger v1alpha1.Jaeger) v1alpha1.Jaeger { +func (s *scraper) collectorPodsState(jaeger v1.Jaeger) v1.Jaeger { if s.targetPort == 0 { s.targetPort = 14268 } @@ -71,8 +71,8 @@ func (s *scraper) collectorPodsState(jaeger v1alpha1.Jaeger) v1alpha1.Jaeger { return s.matchingPodsState(jaeger, opts) } -func (s *scraper) matchingPodsState(jaeger v1alpha1.Jaeger, opts *client.ListOptions) v1alpha1.Jaeger { - list := &v1.PodList{} +func (s *scraper) matchingPodsState(jaeger v1.Jaeger, opts *client.ListOptions) v1.Jaeger { + list := &corev1.PodList{} if err := s.ksClient.List(context.Background(), opts, list); err != nil { jaeger.Logger().WithError(err).Error("failed to obtain the list of collectors") return jaeger @@ -83,7 +83,7 @@ func (s *scraper) matchingPodsState(jaeger v1alpha1.Jaeger, opts *client.ListOpt jaeger.Logger().WithField("name", pod.Name).Debug("pod is part of the instance") // the pod might still be starting, or terminating... we want metrics only from running pods - if pod.Status.Phase == v1.PodRunning { + if pod.Status.Phase == corev1.PodRunning { url := fmt.Sprintf("http://%s:%d/metrics", pod.Status.PodIP, s.targetPort) jaeger = s.aggregate(jaeger, url) } @@ -92,7 +92,7 @@ func (s *scraper) matchingPodsState(jaeger v1alpha1.Jaeger, opts *client.ListOpt return jaeger } -func (s *scraper) aggregate(jaeger v1alpha1.Jaeger, url string) v1alpha1.Jaeger { +func (s *scraper) aggregate(jaeger v1.Jaeger, url string) v1.Jaeger { req, err := http.NewRequest(http.MethodGet, url, nil) res, err := s.hClient.Do(req) if err != nil { @@ -121,7 +121,7 @@ func (s *scraper) aggregate(jaeger v1alpha1.Jaeger, url string) v1alpha1.Jaeger return jaeger } -func (s *scraper) extractMetric(jaeger v1alpha1.Jaeger, metricLine string) v1alpha1.Jaeger { +func (s *scraper) extractMetric(jaeger v1.Jaeger, metricLine string) v1.Jaeger { // process only lines with collector metrics if !strings.HasPrefix(metricLine, "jaeger_collector_") { return jaeger @@ -146,7 +146,7 @@ func (s *scraper) extractMetric(jaeger v1alpha1.Jaeger, metricLine string) v1alp return jaeger } -func valueFor(jaeger v1alpha1.Jaeger, v string) int { +func valueFor(jaeger v1.Jaeger, v string) int { value, err := strconv.Atoi(v) if err != nil { jaeger.Logger().WithFields(log.Fields{ diff --git a/pkg/controller/jaeger/status/collector_test.go b/pkg/controller/jaeger/status/collector_test.go index 0f736ce2c..c246eb87a 100644 --- a/pkg/controller/jaeger/status/collector_test.go +++ b/pkg/controller/jaeger/status/collector_test.go @@ -8,19 +8,19 @@ import ( "testing" "github.com/stretchr/testify/assert" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/runtime" "sigs.k8s.io/controller-runtime/pkg/client/fake" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestPodsArePending(t *testing.T) { - jaeger := v1alpha1.Jaeger{} + jaeger := v1.Jaeger{} - pod := v1.Pod{ - Status: v1.PodStatus{ - Phase: v1.PodPending, + pod := corev1.Pod{ + Status: corev1.PodStatus{ + Phase: corev1.PodPending, }, } objs := []runtime.Object{ @@ -35,12 +35,12 @@ func TestPodsArePending(t *testing.T) { } func TestPodsAreRunning(t *testing.T) { - assertMetricsAreCollected(t, v1alpha1.Jaeger{}) + assertMetricsAreCollected(t, v1.Jaeger{}) } func TestOldStatusIsReplaced(t *testing.T) { - assertMetricsAreCollected(t, v1alpha1.Jaeger{ - Status: v1alpha1.JaegerStatus{ + assertMetricsAreCollected(t, v1.Jaeger{ + Status: v1.JaegerStatus{ CollectorSpansDropped: 2000, CollectorSpansReceived: 3000, }, @@ -48,8 +48,8 @@ func TestOldStatusIsReplaced(t *testing.T) { } func TestAllInOnePodsAreRunning(t *testing.T) { - jaeger := v1alpha1.Jaeger{ - Spec: v1alpha1.JaegerSpec{ + jaeger := v1.Jaeger{ + Spec: v1.JaegerSpec{ Strategy: "allInOne", }, } @@ -76,7 +76,7 @@ func TestUnexpectedStatusCode(t *testing.T) { assertZeroMetricsOnFailure(t, server) } -func assertMetricsAreCollected(t *testing.T, jaeger v1alpha1.Jaeger) { +func assertMetricsAreCollected(t *testing.T, jaeger v1.Jaeger) { server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) { rw.Write([]byte(response)) })) @@ -86,9 +86,9 @@ func assertMetricsAreCollected(t *testing.T, jaeger v1alpha1.Jaeger) { port, err := strconv.Atoi(server.URL[strings.LastIndex(server.URL, ":")+1:]) assert.NoError(t, err) - pod := v1.Pod{ - Status: v1.PodStatus{ - Phase: v1.PodRunning, + pod := corev1.Pod{ + Status: corev1.PodStatus{ + Phase: corev1.PodRunning, PodIP: "127.0.0.1", }, } @@ -105,14 +105,14 @@ func assertMetricsAreCollected(t *testing.T, jaeger v1alpha1.Jaeger) { } func assertZeroMetricsOnFailure(t *testing.T, server *httptest.Server) { - jaeger := v1alpha1.Jaeger{} + jaeger := v1.Jaeger{} port, err := strconv.Atoi(server.URL[strings.LastIndex(server.URL, ":")+1:]) assert.NoError(t, err) - pod := v1.Pod{ - Status: v1.PodStatus{ - Phase: v1.PodRunning, + pod := corev1.Pod{ + Status: corev1.PodStatus{ + Phase: corev1.PodRunning, PodIP: "127.0.0.1", }, } diff --git a/pkg/controller/legacy/legacy_controller.go b/pkg/controller/legacy/legacy_controller.go new file mode 100644 index 000000000..f8392fe62 --- /dev/null +++ b/pkg/controller/legacy/legacy_controller.go @@ -0,0 +1,84 @@ +package legacy + +import ( + "context" + + log "github.com/sirupsen/logrus" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/runtime" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/controller" + "sigs.k8s.io/controller-runtime/pkg/handler" + "sigs.k8s.io/controller-runtime/pkg/manager" + "sigs.k8s.io/controller-runtime/pkg/reconcile" + "sigs.k8s.io/controller-runtime/pkg/source" + + "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" +) + +// Add creates a new Jaeger Controller and adds it to the Manager. The Manager will set fields on the Controller +// and Start it when the Manager is Started. +func Add(mgr manager.Manager) error { + return add(mgr, newReconciler(mgr)) +} + +// newReconciler returns a new reconcile.Reconciler +func newReconciler(mgr manager.Manager) reconcile.Reconciler { + return &ReconcileJaeger{client: mgr.GetClient(), scheme: mgr.GetScheme()} +} + +// add adds a new Controller to mgr with r as the reconcile.Reconciler +func add(mgr manager.Manager, r reconcile.Reconciler) error { + // Create a new controller + c, err := controller.New("legacy-controller", mgr, controller.Options{Reconciler: r}) + if err != nil { + return err + } + + // Watch for changes to primary resource Jaeger + err = c.Watch(&source.Kind{Type: &v1alpha1.Jaeger{}}, &handler.EnqueueRequestForObject{}) + if err != nil { + log.Debug("Legacy CRD not found. Legacy controller will not be active.") + } + + return nil +} + +var _ reconcile.Reconciler = &ReconcileJaeger{} + +// ReconcileJaeger reconciles a Jaeger object +type ReconcileJaeger struct { + // This client, initialized using mgr.Client() above, is a split client + // that reads objects from the cache and writes to the apiserver + client client.Client + scheme *runtime.Scheme +} + +// Reconcile reads that state of the cluster for a Jaeger object and makes changes based on the state read +// and what is in the Jaeger.Spec +// Note: +// The Controller will requeue the Request to be processed again if the returned error is non-nil or +// Result.Requeue is true, otherwise upon completion it will remove the work from the queue. +func (r *ReconcileJaeger) Reconcile(request reconcile.Request) (reconcile.Result, error) { + // Fetch the Jaeger instance + instance := &v1alpha1.Jaeger{} + err := r.client.Get(context.Background(), request.NamespacedName, instance) + if err != nil { + if errors.IsNotFound(err) { + // Request object not found, could have been deleted after reconcile request. + // Owned objects are automatically garbage collected. For additional cleanup logic use finalizers. + // Return and don't requeue + return reconcile.Result{}, nil + } + // Error reading the object - requeue the request. + return reconcile.Result{}, err + } + + log.WithFields(log.Fields{ + "namespace": request.Namespace, + "instance": request.Name, + }).Warn("Attention: you are using a legacy CR for Jaeger. Use the apiVersion 'jaegertracing.io/v1' instead of 'io.jaegertracing/v1alpha1'") + + // reconcile in a few seconds, to get the status object updated + return reconcile.Result{}, nil +} diff --git a/pkg/cronjob/es_index_cleaner.go b/pkg/cronjob/es_index_cleaner.go index 6e608b6c3..531852ce3 100644 --- a/pkg/cronjob/es_index_cleaner.go +++ b/pkg/cronjob/es_index_cleaner.go @@ -7,24 +7,24 @@ import ( batchv1 "k8s.io/api/batch/v1" batchv1beta1 "k8s.io/api/batch/v1beta1" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) // CreateEsIndexCleaner returns a new cronjob for the Elasticsearch Index Cleaner operation -func CreateEsIndexCleaner(jaeger *v1alpha1.Jaeger) *batchv1beta1.CronJob { +func CreateEsIndexCleaner(jaeger *v1.Jaeger) *batchv1beta1.CronJob { esUrls := getEsHostname(jaeger.Spec.Storage.Options.Map()) trueVar := true one := int32(1) name := fmt.Sprintf("%s-es-index-cleaner", jaeger.Name) - var envFromSource []v1.EnvFromSource + var envFromSource []corev1.EnvFromSource if len(jaeger.Spec.Storage.SecretName) > 0 { - envFromSource = append(envFromSource, v1.EnvFromSource{ - SecretRef: &v1.SecretEnvSource{ - LocalObjectReference: v1.LocalObjectReference{ + envFromSource = append(envFromSource, corev1.EnvFromSource{ + SecretRef: &corev1.SecretEnvSource{ + LocalObjectReference: corev1.LocalObjectReference{ Name: jaeger.Spec.Storage.SecretName, }, }, @@ -58,18 +58,18 @@ func CreateEsIndexCleaner(jaeger *v1alpha1.Jaeger) *batchv1beta1.CronJob { JobTemplate: batchv1beta1.JobTemplateSpec{ Spec: batchv1.JobSpec{ Parallelism: &one, - Template: v1.PodTemplateSpec{ - Spec: v1.PodSpec{ - Containers: []v1.Container{ + Template: corev1.PodTemplateSpec{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ { Image: jaeger.Spec.Storage.EsIndexCleaner.Image, Name: name, - Env: removeEmptyVars([]v1.EnvVar{{Name: "INDEX_PREFIX", Value: jaeger.Spec.Storage.Options.Map()["es.index-prefix"]}}), + Env: removeEmptyVars([]corev1.EnvVar{{Name: "INDEX_PREFIX", Value: jaeger.Spec.Storage.Options.Map()["es.index-prefix"]}}), Args: []string{strconv.Itoa(jaeger.Spec.Storage.EsIndexCleaner.NumberOfDays), esUrls}, EnvFrom: envFromSource, }, }, - RestartPolicy: v1.RestartPolicyNever, + RestartPolicy: corev1.RestartPolicyNever, }, ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{ diff --git a/pkg/cronjob/es_index_cleaner_test.go b/pkg/cronjob/es_index_cleaner_test.go index 931380a56..8fa7c2d2a 100644 --- a/pkg/cronjob/es_index_cleaner_test.go +++ b/pkg/cronjob/es_index_cleaner_test.go @@ -5,7 +5,7 @@ import ( "github.com/stretchr/testify/assert" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestGetEsHostname(t *testing.T) { @@ -24,7 +24,7 @@ func TestGetEsHostname(t *testing.T) { } func TestCreateEsIndexCleaner(t *testing.T) { - jaeger := &v1alpha1.Jaeger{Spec: v1alpha1.JaegerSpec{Storage: v1alpha1.JaegerStorageSpec{Options: v1alpha1.NewOptions( + jaeger := &v1.Jaeger{Spec: v1.JaegerSpec{Storage: v1.JaegerStorageSpec{Options: v1.NewOptions( map[string]interface{}{"es.index-prefix": "tenant1", "es.server-urls": "http://nowhere:666,foo"})}}} cronJob := CreateEsIndexCleaner(jaeger) assert.Equal(t, 2, len(cronJob.Spec.JobTemplate.Spec.Template.Spec.Containers[0].Args)) @@ -36,7 +36,7 @@ func TestCreateEsIndexCleaner(t *testing.T) { } func TestEsIndexCleanerSecrets(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestEsIndexCleanerSecrets") + jaeger := v1.NewJaeger("TestEsIndexCleanerSecrets") secret := "mysecret" jaeger.Spec.Storage.SecretName = secret diff --git a/pkg/cronjob/spark_dependencies.go b/pkg/cronjob/spark_dependencies.go index a40d3c9a9..6be7f2ae8 100644 --- a/pkg/cronjob/spark_dependencies.go +++ b/pkg/cronjob/spark_dependencies.go @@ -7,10 +7,10 @@ import ( batchv1 "k8s.io/api/batch/v1" batchv1beta1 "k8s.io/api/batch/v1beta1" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/storage" ) @@ -22,8 +22,8 @@ func SupportedStorage(storage string) bool { } // CreateSparkDependencies creates a new cronjob for the Spark Dependencies task -func CreateSparkDependencies(jaeger *v1alpha1.Jaeger) *batchv1beta1.CronJob { - envVars := []v1.EnvVar{ +func CreateSparkDependencies(jaeger *v1.Jaeger) *batchv1beta1.CronJob { + envVars := []corev1.EnvVar{ {Name: "STORAGE", Value: jaeger.Spec.Storage.Type}, {Name: "SPARK_MASTER", Value: jaeger.Spec.Storage.SparkDependencies.SparkMaster}, {Name: "JAVA_OPTS", Value: jaeger.Spec.Storage.SparkDependencies.JavaOpts}, @@ -61,9 +61,9 @@ func CreateSparkDependencies(jaeger *v1alpha1.Jaeger) *batchv1beta1.CronJob { JobTemplate: batchv1beta1.JobTemplateSpec{ Spec: batchv1.JobSpec{ Parallelism: &one, - Template: v1.PodTemplateSpec{ - Spec: v1.PodSpec{ - Containers: []v1.Container{ + Template: corev1.PodTemplateSpec{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ { Image: jaeger.Spec.Storage.SparkDependencies.Image, Name: name, @@ -71,7 +71,7 @@ func CreateSparkDependencies(jaeger *v1alpha1.Jaeger) *batchv1beta1.CronJob { Env: removeEmptyVars(envVars), }, }, - RestartPolicy: v1.RestartPolicyNever, + RestartPolicy: corev1.RestartPolicyNever, }, ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{ @@ -86,7 +86,7 @@ func CreateSparkDependencies(jaeger *v1alpha1.Jaeger) *batchv1beta1.CronJob { } } -func getStorageEnvs(s v1alpha1.JaegerStorageSpec) []v1.EnvVar { +func getStorageEnvs(s v1.JaegerStorageSpec) []corev1.EnvVar { sFlags := s.Options.Filter(storage.OptionsPrefix(s.Type)) sFlagsMap := sFlags.Map() keyspace := sFlagsMap["cassandra.keyspace"] @@ -95,7 +95,7 @@ func getStorageEnvs(s v1alpha1.JaegerStorageSpec) []v1.EnvVar { } switch s.Type { case "cassandra": - return []v1.EnvVar{ + return []corev1.EnvVar{ {Name: "CASSANDRA_CONTACT_POINTS", Value: sFlagsMap["cassandra.servers"]}, {Name: "CASSANDRA_KEYSPACE", Value: keyspace}, {Name: "CASSANDRA_USERNAME", Value: sFlagsMap["cassandra.username"]}, @@ -105,7 +105,7 @@ func getStorageEnvs(s v1alpha1.JaegerStorageSpec) []v1.EnvVar { {Name: "CASSANDRA_CLIENT_AUTH_ENABLED", Value: strconv.FormatBool(s.SparkDependencies.CassandraClientAuthEnabled)}, } case "elasticsearch": - return []v1.EnvVar{ + return []corev1.EnvVar{ {Name: "ES_NODES", Value: sFlagsMap["es.server-urls"]}, {Name: "ES_INDEX_PREFIX", Value: sFlagsMap["es.index-prefix"]}, {Name: "ES_USERNAME", Value: sFlagsMap["es.username"]}, @@ -118,8 +118,8 @@ func getStorageEnvs(s v1alpha1.JaegerStorageSpec) []v1.EnvVar { } } -func removeEmptyVars(envVars []v1.EnvVar) []v1.EnvVar { - var notEmpty []v1.EnvVar +func removeEmptyVars(envVars []corev1.EnvVar) []corev1.EnvVar { + var notEmpty []corev1.EnvVar for _, v := range envVars { if v.Value != "" || v.ValueFrom != nil { notEmpty = append(notEmpty, v) diff --git a/pkg/cronjob/spark_dependencies_test.go b/pkg/cronjob/spark_dependencies_test.go index 3961058c1..7d9ecd575 100644 --- a/pkg/cronjob/spark_dependencies_test.go +++ b/pkg/cronjob/spark_dependencies_test.go @@ -4,20 +4,20 @@ import ( "testing" "github.com/stretchr/testify/assert" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestRemoveEmptyVars(t *testing.T) { tests := []struct { - underTest []v1.EnvVar - expected []v1.EnvVar + underTest []corev1.EnvVar + expected []corev1.EnvVar }{ {}, - {underTest: []v1.EnvVar{{Name: "foo", Value: "bar"}, {Name: "foo3"}, {Name: "foo2", ValueFrom: &v1.EnvVarSource{}}}, - expected: []v1.EnvVar{{Name: "foo", Value: "bar"}, {Name: "foo2", ValueFrom: &v1.EnvVarSource{}}}}, - {underTest: []v1.EnvVar{{Name: "foo"}}}, + {underTest: []corev1.EnvVar{{Name: "foo", Value: "bar"}, {Name: "foo3"}, {Name: "foo2", ValueFrom: &corev1.EnvVarSource{}}}, + expected: []corev1.EnvVar{{Name: "foo", Value: "bar"}, {Name: "foo2", ValueFrom: &corev1.EnvVarSource{}}}}, + {underTest: []corev1.EnvVar{{Name: "foo"}}}, } for _, test := range tests { exp := removeEmptyVars(test.underTest) @@ -27,14 +27,14 @@ func TestRemoveEmptyVars(t *testing.T) { func TestStorageEnvs(t *testing.T) { tests := []struct { - storage v1alpha1.JaegerStorageSpec - expected []v1.EnvVar + storage v1.JaegerStorageSpec + expected []corev1.EnvVar }{ - {storage: v1alpha1.JaegerStorageSpec{Type: "foo"}}, - {storage: v1alpha1.JaegerStorageSpec{Type: "cassandra", - Options: v1alpha1.NewOptions(map[string]interface{}{"cassandra.servers": "lol:hol", "cassandra.keyspace": "haha", + {storage: v1.JaegerStorageSpec{Type: "foo"}}, + {storage: v1.JaegerStorageSpec{Type: "cassandra", + Options: v1.NewOptions(map[string]interface{}{"cassandra.servers": "lol:hol", "cassandra.keyspace": "haha", "cassandra.username": "jdoe", "cassandra.password": "none"})}, - expected: []v1.EnvVar{ + expected: []corev1.EnvVar{ {Name: "CASSANDRA_CONTACT_POINTS", Value: "lol:hol"}, {Name: "CASSANDRA_KEYSPACE", Value: "haha"}, {Name: "CASSANDRA_USERNAME", Value: "jdoe"}, @@ -43,10 +43,10 @@ func TestStorageEnvs(t *testing.T) { {Name: "CASSANDRA_LOCAL_DC", Value: ""}, {Name: "CASSANDRA_CLIENT_AUTH_ENABLED", Value: "false"}, }}, - {storage: v1alpha1.JaegerStorageSpec{Type: "elasticsearch", - Options: v1alpha1.NewOptions(map[string]interface{}{"es.server-urls": "lol:hol", "es.index-prefix": "haha", + {storage: v1.JaegerStorageSpec{Type: "elasticsearch", + Options: v1.NewOptions(map[string]interface{}{"es.server-urls": "lol:hol", "es.index-prefix": "haha", "es.username": "jdoe", "es.password": "none"})}, - expected: []v1.EnvVar{ + expected: []corev1.EnvVar{ {Name: "ES_NODES", Value: "lol:hol"}, {Name: "ES_INDEX_PREFIX", Value: "haha"}, {Name: "ES_USERNAME", Value: "jdoe"}, @@ -62,5 +62,5 @@ func TestStorageEnvs(t *testing.T) { } func TestCreate(t *testing.T) { - assert.NotNil(t, CreateSparkDependencies(&v1alpha1.Jaeger{Spec: v1alpha1.JaegerSpec{Storage: v1alpha1.JaegerStorageSpec{Type: "elasticsearch"}}})) + assert.NotNil(t, CreateSparkDependencies(&v1.Jaeger{Spec: v1.JaegerSpec{Storage: v1.JaegerStorageSpec{Type: "elasticsearch"}}})) } diff --git a/pkg/deployment/agent.go b/pkg/deployment/agent.go index 1d056ffc7..cb1dd6858 100644 --- a/pkg/deployment/agent.go +++ b/pkg/deployment/agent.go @@ -6,21 +6,21 @@ import ( "github.com/spf13/viper" appsv1 "k8s.io/api/apps/v1" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/service" "github.com/jaegertracing/jaeger-operator/pkg/util" ) // Agent builds pods for jaegertracing/jaeger-agent type Agent struct { - jaeger *v1alpha1.Jaeger + jaeger *v1.Jaeger } // NewAgent builds a new Agent struct based on the given spec -func NewAgent(jaeger *v1alpha1.Jaeger) *Agent { +func NewAgent(jaeger *v1.Jaeger) *Agent { if jaeger.Spec.Agent.Image == "" { jaeger.Spec.Agent.Image = fmt.Sprintf("%s:%s", viper.GetString("jaeger-agent-image"), viper.GetString("jaeger-version")) } @@ -39,7 +39,7 @@ func (a *Agent) Get() *appsv1.DaemonSet { trueVar := true labels := a.labels() - baseCommonSpec := v1alpha1.JaegerCommonSpec{ + baseCommonSpec := v1.JaegerCommonSpec{ Annotations: map[string]string{ "prometheus.io/scrape": "true", "prometheus.io/port": "5778", @@ -47,7 +47,7 @@ func (a *Agent) Get() *appsv1.DaemonSet { }, } - commonSpec := util.Merge([]v1alpha1.JaegerCommonSpec{a.jaeger.Spec.Agent.JaegerCommonSpec, a.jaeger.Spec.JaegerCommonSpec, baseCommonSpec}) + commonSpec := util.Merge([]v1.JaegerCommonSpec{a.jaeger.Spec.Agent.JaegerCommonSpec, a.jaeger.Spec.JaegerCommonSpec, baseCommonSpec}) return &appsv1.DaemonSet{ TypeMeta: metav1.TypeMeta{ @@ -72,22 +72,22 @@ func (a *Agent) Get() *appsv1.DaemonSet { Selector: &metav1.LabelSelector{ MatchLabels: labels, }, - Template: v1.PodTemplateSpec{ + Template: corev1.PodTemplateSpec{ ObjectMeta: metav1.ObjectMeta{ Labels: labels, Annotations: commonSpec.Annotations, }, - Spec: v1.PodSpec{ - Containers: []v1.Container{{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{{ Image: a.jaeger.Spec.Agent.Image, Name: "jaeger-agent-daemonset", Args: args, - Ports: []v1.ContainerPort{ + Ports: []corev1.ContainerPort{ { ContainerPort: 5775, HostPort: 5775, Name: "zk-compact-trft", - Protocol: v1.ProtocolUDP, + Protocol: corev1.ProtocolUDP, }, { ContainerPort: 5778, @@ -98,19 +98,19 @@ func (a *Agent) Get() *appsv1.DaemonSet { ContainerPort: 6831, HostPort: 6831, Name: "jg-compact-trft", - Protocol: v1.ProtocolUDP, + Protocol: corev1.ProtocolUDP, }, { ContainerPort: 6832, HostPort: 6832, Name: "jg-binary-trft", - Protocol: v1.ProtocolUDP, + Protocol: corev1.ProtocolUDP, }, }, // TODO(jpkroehling): enable it back once a version with jaegertracing/jaeger#1178 is released - // ReadinessProbe: &v1.Probe{ - // Handler: v1.Handler{ - // HTTPGet: &v1.HTTPGetAction{ + // ReadinessProbe: &corev1.Probe{ + // Handler: corev1.Handler{ + // HTTPGet: &corev1.HTTPGetAction{ // Path: "/metrics", // Port: intstr.FromInt(5778), // }, diff --git a/pkg/deployment/agent_test.go b/pkg/deployment/agent_test.go index d2f4b7a61..269e99a5b 100644 --- a/pkg/deployment/agent_test.go +++ b/pkg/deployment/agent_test.go @@ -6,10 +6,10 @@ import ( "github.com/spf13/viper" "github.com/stretchr/testify/assert" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/api/resource" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func setDefaults() { @@ -27,7 +27,7 @@ func reset() { } func TestNewAgent(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestNewAgent") + jaeger := v1.NewJaeger("TestNewAgent") NewAgent(jaeger) assert.Contains(t, jaeger.Spec.Agent.Image, "jaeger-agent") } @@ -37,26 +37,26 @@ func TestDefaultAgentImage(t *testing.T) { viper.Set("jaeger-version", "123") defer reset() - jaeger := v1alpha1.NewJaeger("TestNewAgent") + jaeger := v1.NewJaeger("TestNewAgent") NewAgent(jaeger) assert.Equal(t, "org/custom-agent-image:123", jaeger.Spec.Agent.Image) } func TestGetDefaultAgentDeployment(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestNewAgent") + jaeger := v1.NewJaeger("TestNewAgent") agent := NewAgent(jaeger) assert.Nil(t, agent.Get()) // it's not implemented yet } func TestGetSidecarDeployment(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestNewAgent") + jaeger := v1.NewJaeger("TestNewAgent") jaeger.Spec.Agent.Strategy = "sidecar" agent := NewAgent(jaeger) assert.Nil(t, agent.Get()) // it's not implemented yet } func TestGetDaemonSetDeployment(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestNewAgent") + jaeger := v1.NewJaeger("TestNewAgent") jaeger.Spec.Agent.Strategy = "daemonset" agent := NewAgent(jaeger) @@ -65,7 +65,7 @@ func TestGetDaemonSetDeployment(t *testing.T) { } func TestDaemonSetAgentAnnotations(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestDaemonSetAgentAnnotations") + jaeger := v1.NewJaeger("TestDaemonSetAgentAnnotations") jaeger.Spec.Agent.Strategy = "daemonset" jaeger.Spec.Annotations = map[string]string{ "name": "operator", @@ -86,42 +86,42 @@ func TestDaemonSetAgentAnnotations(t *testing.T) { } func TestDaemonSetAgentResources(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestDaemonSetAgentResources") + jaeger := v1.NewJaeger("TestDaemonSetAgentResources") jaeger.Spec.Agent.Strategy = "daemonset" - jaeger.Spec.Resources = v1.ResourceRequirements{ - Limits: v1.ResourceList{ - v1.ResourceLimitsCPU: *resource.NewQuantity(1024, resource.BinarySI), - v1.ResourceLimitsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), + jaeger.Spec.Resources = corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + corev1.ResourceLimitsCPU: *resource.NewQuantity(1024, resource.BinarySI), + corev1.ResourceLimitsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), }, - Requests: v1.ResourceList{ - v1.ResourceRequestsCPU: *resource.NewQuantity(1024, resource.BinarySI), - v1.ResourceRequestsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), + Requests: corev1.ResourceList{ + corev1.ResourceRequestsCPU: *resource.NewQuantity(1024, resource.BinarySI), + corev1.ResourceRequestsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), }, } - jaeger.Spec.Agent.Resources = v1.ResourceRequirements{ - Limits: v1.ResourceList{ - v1.ResourceLimitsCPU: *resource.NewQuantity(2048, resource.BinarySI), - v1.ResourceLimitsMemory: *resource.NewQuantity(123, resource.DecimalSI), + jaeger.Spec.Agent.Resources = corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + corev1.ResourceLimitsCPU: *resource.NewQuantity(2048, resource.BinarySI), + corev1.ResourceLimitsMemory: *resource.NewQuantity(123, resource.DecimalSI), }, - Requests: v1.ResourceList{ - v1.ResourceRequestsCPU: *resource.NewQuantity(2048, resource.BinarySI), - v1.ResourceRequestsMemory: *resource.NewQuantity(123, resource.DecimalSI), + Requests: corev1.ResourceList{ + corev1.ResourceRequestsCPU: *resource.NewQuantity(2048, resource.BinarySI), + corev1.ResourceRequestsMemory: *resource.NewQuantity(123, resource.DecimalSI), }, } agent := NewAgent(jaeger) dep := agent.Get() - assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[v1.ResourceLimitsCPU]) - assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[v1.ResourceRequestsCPU]) - assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[v1.ResourceLimitsMemory]) - assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[v1.ResourceRequestsMemory]) - assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[v1.ResourceLimitsEphemeralStorage]) - assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[v1.ResourceRequestsEphemeralStorage]) + assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[corev1.ResourceLimitsCPU]) + assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[corev1.ResourceRequestsCPU]) + assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[corev1.ResourceLimitsMemory]) + assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[corev1.ResourceRequestsMemory]) + assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[corev1.ResourceLimitsEphemeralStorage]) + assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[corev1.ResourceRequestsEphemeralStorage]) } func TestAgentLabels(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestAgentLabels") + jaeger := v1.NewJaeger("TestAgentLabels") jaeger.Spec.Agent.Strategy = "daemonset" a := NewAgent(jaeger) dep := a.Get() diff --git a/pkg/deployment/all-in-one.go b/pkg/deployment/all-in-one.go index 7f618d5a7..9e3bdb182 100644 --- a/pkg/deployment/all-in-one.go +++ b/pkg/deployment/all-in-one.go @@ -5,12 +5,12 @@ import ( "github.com/spf13/viper" appsv1 "k8s.io/api/apps/v1" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/intstr" "github.com/jaegertracing/jaeger-operator/pkg/account" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/config/sampling" "github.com/jaegertracing/jaeger-operator/pkg/config/ui" "github.com/jaegertracing/jaeger-operator/pkg/service" @@ -20,11 +20,11 @@ import ( // AllInOne builds pods for jaegertracing/all-in-one type AllInOne struct { - jaeger *v1alpha1.Jaeger + jaeger *v1.Jaeger } // NewAllInOne builds a new AllInOne struct based on the given spec -func NewAllInOne(jaeger *v1alpha1.Jaeger) *AllInOne { +func NewAllInOne(jaeger *v1.Jaeger) *AllInOne { if jaeger.Spec.AllInOne.Image == "" { jaeger.Spec.AllInOne.Image = fmt.Sprintf("%s:%s", viper.GetString("jaeger-all-in-one-image"), viper.GetString("jaeger-version")) } @@ -38,7 +38,7 @@ func (a *AllInOne) Get() *appsv1.Deployment { labels := a.labels() trueVar := true - baseCommonSpec := v1alpha1.JaegerCommonSpec{ + baseCommonSpec := v1.JaegerCommonSpec{ Annotations: map[string]string{ "prometheus.io/scrape": "true", "prometheus.io/port": "16686", @@ -46,7 +46,7 @@ func (a *AllInOne) Get() *appsv1.Deployment { }, } - commonSpec := util.Merge([]v1alpha1.JaegerCommonSpec{a.jaeger.Spec.AllInOne.JaegerCommonSpec, a.jaeger.Spec.JaegerCommonSpec, baseCommonSpec}) + commonSpec := util.Merge([]v1.JaegerCommonSpec{a.jaeger.Spec.AllInOne.JaegerCommonSpec, a.jaeger.Spec.JaegerCommonSpec, baseCommonSpec}) options := allArgs(a.jaeger.Spec.AllInOne.Options, a.jaeger.Spec.Storage.Options.Filter(storage.OptionsPrefix(a.jaeger.Spec.Storage.Type))) @@ -54,11 +54,11 @@ func (a *AllInOne) Get() *appsv1.Deployment { configmap.Update(a.jaeger, commonSpec, &options) sampling.Update(a.jaeger, commonSpec, &options) - var envFromSource []v1.EnvFromSource + var envFromSource []corev1.EnvFromSource if len(a.jaeger.Spec.Storage.SecretName) > 0 { - envFromSource = append(envFromSource, v1.EnvFromSource{ - SecretRef: &v1.SecretEnvSource{ - LocalObjectReference: v1.LocalObjectReference{ + envFromSource = append(envFromSource, corev1.EnvFromSource{ + SecretRef: &corev1.SecretEnvSource{ + LocalObjectReference: corev1.LocalObjectReference{ Name: a.jaeger.Spec.Storage.SecretName, }, }, @@ -89,33 +89,33 @@ func (a *AllInOne) Get() *appsv1.Deployment { Selector: &metav1.LabelSelector{ MatchLabels: labels, }, - Template: v1.PodTemplateSpec{ + Template: corev1.PodTemplateSpec{ ObjectMeta: metav1.ObjectMeta{ Labels: labels, Annotations: commonSpec.Annotations, }, - Spec: v1.PodSpec{ - Containers: []v1.Container{{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{{ Image: a.jaeger.Spec.AllInOne.Image, Name: "jaeger", Args: options, - Env: []v1.EnvVar{ - v1.EnvVar{ + Env: []corev1.EnvVar{ + corev1.EnvVar{ Name: "SPAN_STORAGE_TYPE", Value: a.jaeger.Spec.Storage.Type, }, - v1.EnvVar{ + corev1.EnvVar{ Name: "COLLECTOR_ZIPKIN_HTTP_PORT", Value: "9411", }, }, VolumeMounts: commonSpec.VolumeMounts, EnvFrom: envFromSource, - Ports: []v1.ContainerPort{ + Ports: []corev1.ContainerPort{ { ContainerPort: 5775, Name: "zk-compact-trft", // max 15 chars! - Protocol: v1.ProtocolUDP, + Protocol: corev1.ProtocolUDP, }, { ContainerPort: 5778, @@ -124,12 +124,12 @@ func (a *AllInOne) Get() *appsv1.Deployment { { ContainerPort: 6831, Name: "jg-compact-trft", - Protocol: v1.ProtocolUDP, + Protocol: corev1.ProtocolUDP, }, { ContainerPort: 6832, Name: "jg-binary-trft", - Protocol: v1.ProtocolUDP, + Protocol: corev1.ProtocolUDP, }, { ContainerPort: 9411, @@ -148,9 +148,9 @@ func (a *AllInOne) Get() *appsv1.Deployment { Name: "query", }, }, - ReadinessProbe: &v1.Probe{ - Handler: v1.Handler{ - HTTPGet: &v1.HTTPGetAction{ + ReadinessProbe: &corev1.Probe{ + Handler: corev1.Handler{ + HTTPGet: &corev1.HTTPGetAction{ Path: "/", Port: intstr.FromInt(14269), }, @@ -168,9 +168,9 @@ func (a *AllInOne) Get() *appsv1.Deployment { } // Services returns a list of services to be deployed along with the all-in-one deployment -func (a *AllInOne) Services() []*v1.Service { +func (a *AllInOne) Services() []*corev1.Service { labels := a.labels() - return []*v1.Service{ + return []*corev1.Service{ service.NewCollectorService(a.jaeger, labels), service.NewQueryService(a.jaeger, labels), service.NewAgentService(a.jaeger, labels), diff --git a/pkg/deployment/all-in-one_test.go b/pkg/deployment/all-in-one_test.go index 8b7ca409c..5ecc05e01 100644 --- a/pkg/deployment/all-in-one_test.go +++ b/pkg/deployment/all-in-one_test.go @@ -5,10 +5,10 @@ import ( "github.com/spf13/viper" "github.com/stretchr/testify/assert" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/api/resource" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func init() { @@ -21,12 +21,12 @@ func TestDefaultAllInOneImage(t *testing.T) { viper.Set("jaeger-version", "123") defer viper.Reset() - d := NewAllInOne(v1alpha1.NewJaeger("TestAllInOneDefaultImage")).Get() + d := NewAllInOne(v1.NewJaeger("TestAllInOneDefaultImage")).Get() assert.Len(t, d.Spec.Template.Spec.Containers, 1) assert.Equal(t, "org/custom-all-in-one-image:123", d.Spec.Template.Spec.Containers[0].Image) - envvars := []v1.EnvVar{ + envvars := []corev1.EnvVar{ { Name: "SPAN_STORAGE_TYPE", Value: "", @@ -40,7 +40,7 @@ func TestDefaultAllInOneImage(t *testing.T) { } func TestAllInOneAnnotations(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestAllInOneAnnotations") + jaeger := v1.NewJaeger("TestAllInOneAnnotations") jaeger.Spec.Annotations = map[string]string{ "name": "operator", "hello": "jaeger", @@ -61,13 +61,13 @@ func TestAllInOneAnnotations(t *testing.T) { func TestAllInOneHasOwner(t *testing.T) { name := "TestAllInOneHasOwner" - a := NewAllInOne(v1alpha1.NewJaeger(name)) + a := NewAllInOne(v1.NewJaeger(name)) assert.Equal(t, name, a.Get().ObjectMeta.Name) } func TestAllInOneNumberOfServices(t *testing.T) { name := "TestNumberOfServices" - services := NewAllInOne(v1alpha1.NewJaeger(name)).Services() + services := NewAllInOne(v1.NewJaeger(name)).Services() assert.Len(t, services, 3) // collector, query, agent for _, svc := range services { @@ -79,33 +79,25 @@ func TestAllInOneNumberOfServices(t *testing.T) { func TestAllInOneVolumeMountsWithVolumes(t *testing.T) { name := "TestAllInOneVolumeMountsWithVolumes" - globalVolumes := []v1.Volume{ - { - Name: "globalVolume", - VolumeSource: v1.VolumeSource{}, - }, - } + globalVolumes := []corev1.Volume{{ + Name: "globalVolume", + VolumeSource: corev1.VolumeSource{}, + }} - globalVolumeMounts := []v1.VolumeMount{ - { - Name: "globalVolume", - }, - } + globalVolumeMounts := []corev1.VolumeMount{{ + Name: "globalVolume", + }} - allInOneVolumes := []v1.Volume{ - { - Name: "allInOneVolume", - VolumeSource: v1.VolumeSource{}, - }, - } + allInOneVolumes := []corev1.Volume{{ + Name: "allInOneVolume", + VolumeSource: corev1.VolumeSource{}, + }} - allInOneVolumeMounts := []v1.VolumeMount{ - { - Name: "allInOneVolume", - }, - } + allInOneVolumeMounts := []corev1.VolumeMount{{ + Name: "allInOneVolume", + }} - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) jaeger.Spec.Volumes = globalVolumes jaeger.Spec.VolumeMounts = globalVolumeMounts jaeger.Spec.AllInOne.Volumes = allInOneVolumes @@ -124,7 +116,7 @@ func TestAllInOneVolumeMountsWithVolumes(t *testing.T) { } func TestAllInOneSecrets(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestAllInOneSecrets") + jaeger := v1.NewJaeger("TestAllInOneSecrets") secret := "mysecret" jaeger.Spec.Storage.SecretName = secret @@ -137,21 +129,17 @@ func TestAllInOneSecrets(t *testing.T) { func TestAllInOneMountGlobalVolumes(t *testing.T) { name := "TestAllInOneMountGlobalVolumes" - globalVolumes := []v1.Volume{ - { - Name: "globalVolume", - VolumeSource: v1.VolumeSource{}, - }, - } + globalVolumes := []corev1.Volume{{ + Name: "globalVolume", + VolumeSource: corev1.VolumeSource{}, + }} - allInOneVolumeMounts := []v1.VolumeMount{ - { - Name: "globalVolume", - ReadOnly: true, - }, - } + allInOneVolumeMounts := []corev1.VolumeMount{{ + Name: "globalVolume", + ReadOnly: true, + }} - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) jaeger.Spec.Volumes = globalVolumes jaeger.Spec.AllInOne.VolumeMounts = allInOneVolumeMounts podSpec := NewAllInOne(jaeger).Get().Spec.Template.Spec @@ -165,21 +153,17 @@ func TestAllInOneMountGlobalVolumes(t *testing.T) { func TestAllInOneVolumeMountsWithSameName(t *testing.T) { name := "TestAllInOneVolumeMountsWithSameName" - globalVolumeMounts := []v1.VolumeMount{ - { - Name: "data", - ReadOnly: true, - }, - } + globalVolumeMounts := []corev1.VolumeMount{{ + Name: "data", + ReadOnly: true, + }} - allInOneVolumeMounts := []v1.VolumeMount{ - { - Name: "data", - ReadOnly: false, - }, - } + allInOneVolumeMounts := []corev1.VolumeMount{{ + Name: "data", + ReadOnly: false, + }} - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) jaeger.Spec.VolumeMounts = globalVolumeMounts jaeger.Spec.AllInOne.VolumeMounts = allInOneVolumeMounts podSpec := NewAllInOne(jaeger).Get().Spec.Template.Spec @@ -193,21 +177,17 @@ func TestAllInOneVolumeMountsWithSameName(t *testing.T) { func TestAllInOneVolumeWithSameName(t *testing.T) { name := "TestAllInOneVolumeWithSameName" - globalVolumes := []v1.Volume{ - { - Name: "data", - VolumeSource: v1.VolumeSource{HostPath: &v1.HostPathVolumeSource{Path: "/data1"}}, - }, - } + globalVolumes := []corev1.Volume{{ + Name: "data", + VolumeSource: corev1.VolumeSource{HostPath: &corev1.HostPathVolumeSource{Path: "/data1"}}, + }} - allInOneVolumes := []v1.Volume{ - { - Name: "data", - VolumeSource: v1.VolumeSource{HostPath: &v1.HostPathVolumeSource{Path: "/data2"}}, - }, - } + allInOneVolumes := []corev1.Volume{{ + Name: "data", + VolumeSource: corev1.VolumeSource{HostPath: &corev1.HostPathVolumeSource{Path: "/data2"}}, + }} - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) jaeger.Spec.Volumes = globalVolumes jaeger.Spec.AllInOne.Volumes = allInOneVolumes podSpec := NewAllInOne(jaeger).Get().Spec.Template.Spec @@ -219,41 +199,41 @@ func TestAllInOneVolumeWithSameName(t *testing.T) { } func TestAllInOneResources(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestAllInOneResources") - jaeger.Spec.Resources = v1.ResourceRequirements{ - Limits: v1.ResourceList{ - v1.ResourceLimitsCPU: *resource.NewQuantity(1024, resource.BinarySI), - v1.ResourceLimitsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), + jaeger := v1.NewJaeger("TestAllInOneResources") + jaeger.Spec.Resources = corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + corev1.ResourceLimitsCPU: *resource.NewQuantity(1024, resource.BinarySI), + corev1.ResourceLimitsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), }, - Requests: v1.ResourceList{ - v1.ResourceRequestsCPU: *resource.NewQuantity(1024, resource.BinarySI), - v1.ResourceRequestsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), + Requests: corev1.ResourceList{ + corev1.ResourceRequestsCPU: *resource.NewQuantity(1024, resource.BinarySI), + corev1.ResourceRequestsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), }, } - jaeger.Spec.AllInOne.Resources = v1.ResourceRequirements{ - Limits: v1.ResourceList{ - v1.ResourceLimitsCPU: *resource.NewQuantity(2048, resource.BinarySI), - v1.ResourceLimitsMemory: *resource.NewQuantity(123, resource.DecimalSI), + jaeger.Spec.AllInOne.Resources = corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + corev1.ResourceLimitsCPU: *resource.NewQuantity(2048, resource.BinarySI), + corev1.ResourceLimitsMemory: *resource.NewQuantity(123, resource.DecimalSI), }, - Requests: v1.ResourceList{ - v1.ResourceRequestsCPU: *resource.NewQuantity(2048, resource.BinarySI), - v1.ResourceRequestsMemory: *resource.NewQuantity(123, resource.DecimalSI), + Requests: corev1.ResourceList{ + corev1.ResourceRequestsCPU: *resource.NewQuantity(2048, resource.BinarySI), + corev1.ResourceRequestsMemory: *resource.NewQuantity(123, resource.DecimalSI), }, } allinone := NewAllInOne(jaeger) dep := allinone.Get() - assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[v1.ResourceLimitsCPU]) - assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[v1.ResourceRequestsCPU]) - assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[v1.ResourceLimitsMemory]) - assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[v1.ResourceRequestsMemory]) - assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[v1.ResourceLimitsEphemeralStorage]) - assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[v1.ResourceRequestsEphemeralStorage]) + assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[corev1.ResourceLimitsCPU]) + assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[corev1.ResourceRequestsCPU]) + assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[corev1.ResourceLimitsMemory]) + assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[corev1.ResourceRequestsMemory]) + assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[corev1.ResourceLimitsEphemeralStorage]) + assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[corev1.ResourceRequestsEphemeralStorage]) } func TestAllInOneLabels(t *testing.T) { - a := NewAllInOne(v1alpha1.NewJaeger("TestAllInOneLabels")) + a := NewAllInOne(v1.NewJaeger("TestAllInOneLabels")) dep := a.Get() assert.Equal(t, "jaeger-operator", dep.Spec.Template.Labels["app.kubernetes.io/managed-by"]) assert.Equal(t, "all-in-one", dep.Spec.Template.Labels["app.kubernetes.io/component"]) diff --git a/pkg/deployment/args.go b/pkg/deployment/args.go index f0d2403c9..2410e7847 100644 --- a/pkg/deployment/args.go +++ b/pkg/deployment/args.go @@ -1,10 +1,10 @@ package deployment import ( - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) -func allArgs(optionsList ...v1alpha1.Options) []string { +func allArgs(optionsList ...v1.Options) []string { args := []string{} for _, options := range optionsList { args = append(args, options.ToArgs()...) diff --git a/pkg/deployment/args_test.go b/pkg/deployment/args_test.go index 40cd3f954..54ce1a8eb 100644 --- a/pkg/deployment/args_test.go +++ b/pkg/deployment/args_test.go @@ -6,14 +6,14 @@ import ( "github.com/stretchr/testify/assert" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestArgs(t *testing.T) { // prepare - jaeger := v1alpha1.NewJaeger("TestArgs") - jaeger.Spec.Storage.Options = v1alpha1.NewOptions(map[string]interface{}{"memory.max-traces": 10000}) - jaeger.Spec.AllInOne.Options = v1alpha1.NewOptions(map[string]interface{}{"collector.http-port": 14268}) + jaeger := v1.NewJaeger("TestArgs") + jaeger.Spec.Storage.Options = v1.NewOptions(map[string]interface{}{"memory.max-traces": 10000}) + jaeger.Spec.AllInOne.Options = v1.NewOptions(map[string]interface{}{"collector.http-port": 14268}) // test args := allArgs(jaeger.Spec.Storage.Options, jaeger.Spec.AllInOne.Options) diff --git a/pkg/deployment/collector.go b/pkg/deployment/collector.go index 33dbe5ebd..a715eb2b5 100644 --- a/pkg/deployment/collector.go +++ b/pkg/deployment/collector.go @@ -6,12 +6,12 @@ import ( "github.com/spf13/viper" appsv1 "k8s.io/api/apps/v1" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/intstr" "github.com/jaegertracing/jaeger-operator/pkg/account" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/config/sampling" "github.com/jaegertracing/jaeger-operator/pkg/service" "github.com/jaegertracing/jaeger-operator/pkg/storage" @@ -20,11 +20,11 @@ import ( // Collector builds pods for jaegertracing/jaeger-collector type Collector struct { - jaeger *v1alpha1.Jaeger + jaeger *v1.Jaeger } // NewCollector builds a new Collector struct based on the given spec -func NewCollector(jaeger *v1alpha1.Jaeger) *Collector { +func NewCollector(jaeger *v1.Jaeger) *Collector { if jaeger.Spec.Collector.Size <= 0 { jaeger.Spec.Collector.Size = 1 } @@ -44,7 +44,7 @@ func (c *Collector) Get() *appsv1.Deployment { trueVar := true replicas := int32(c.jaeger.Spec.Collector.Size) - baseCommonSpec := v1alpha1.JaegerCommonSpec{ + baseCommonSpec := v1.JaegerCommonSpec{ Annotations: map[string]string{ "prometheus.io/scrape": "true", "prometheus.io/port": "14268", @@ -52,13 +52,13 @@ func (c *Collector) Get() *appsv1.Deployment { }, } - commonSpec := util.Merge([]v1alpha1.JaegerCommonSpec{c.jaeger.Spec.Collector.JaegerCommonSpec, c.jaeger.Spec.JaegerCommonSpec, baseCommonSpec}) + commonSpec := util.Merge([]v1.JaegerCommonSpec{c.jaeger.Spec.Collector.JaegerCommonSpec, c.jaeger.Spec.JaegerCommonSpec, baseCommonSpec}) - var envFromSource []v1.EnvFromSource + var envFromSource []corev1.EnvFromSource if len(c.jaeger.Spec.Storage.SecretName) > 0 { - envFromSource = append(envFromSource, v1.EnvFromSource{ - SecretRef: &v1.SecretEnvSource{ - LocalObjectReference: v1.LocalObjectReference{ + envFromSource = append(envFromSource, corev1.EnvFromSource{ + SecretRef: &corev1.SecretEnvSource{ + LocalObjectReference: corev1.LocalObjectReference{ Name: c.jaeger.Spec.Storage.SecretName, }, }, @@ -102,29 +102,29 @@ func (c *Collector) Get() *appsv1.Deployment { Selector: &metav1.LabelSelector{ MatchLabels: labels, }, - Template: v1.PodTemplateSpec{ + Template: corev1.PodTemplateSpec{ ObjectMeta: metav1.ObjectMeta{ Labels: labels, Annotations: commonSpec.Annotations, }, - Spec: v1.PodSpec{ - Containers: []v1.Container{{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{{ Image: c.jaeger.Spec.Collector.Image, Name: "jaeger-collector", Args: options, - Env: []v1.EnvVar{ - v1.EnvVar{ + Env: []corev1.EnvVar{ + corev1.EnvVar{ Name: "SPAN_STORAGE_TYPE", Value: storageType, }, - v1.EnvVar{ + corev1.EnvVar{ Name: "COLLECTOR_ZIPKIN_HTTP_PORT", Value: "9411", }, }, VolumeMounts: commonSpec.VolumeMounts, EnvFrom: envFromSource, - Ports: []v1.ContainerPort{ + Ports: []corev1.ContainerPort{ { ContainerPort: 9411, Name: "zipkin", @@ -138,9 +138,9 @@ func (c *Collector) Get() *appsv1.Deployment { Name: "c-binary-trft", }, }, - ReadinessProbe: &v1.Probe{ - Handler: v1.Handler{ - HTTPGet: &v1.HTTPGetAction{ + ReadinessProbe: &corev1.Probe{ + Handler: corev1.Handler{ + HTTPGet: &corev1.HTTPGetAction{ Path: "/", Port: intstr.FromInt(14269), }, @@ -158,8 +158,8 @@ func (c *Collector) Get() *appsv1.Deployment { } // Services returns a list of services to be deployed along with the all-in-one deployment -func (c *Collector) Services() []*v1.Service { - return []*v1.Service{ +func (c *Collector) Services() []*corev1.Service { + return []*corev1.Service{ service.NewCollectorService(c.jaeger, c.labels()), } } diff --git a/pkg/deployment/collector_test.go b/pkg/deployment/collector_test.go index 8cff8d41e..fb4c43e97 100644 --- a/pkg/deployment/collector_test.go +++ b/pkg/deployment/collector_test.go @@ -6,11 +6,11 @@ import ( "github.com/spf13/viper" "github.com/stretchr/testify/assert" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/api/resource" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func init() { @@ -19,7 +19,7 @@ func init() { } func TestNegativeSize(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestNegativeSize") + jaeger := v1.NewJaeger("TestNegativeSize") jaeger.Spec.Collector.Size = -1 collector := NewCollector(jaeger) @@ -28,7 +28,7 @@ func TestNegativeSize(t *testing.T) { } func TestDefaultSize(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestDefaultSize") + jaeger := v1.NewJaeger("TestDefaultSize") jaeger.Spec.Collector.Size = 0 collector := NewCollector(jaeger) @@ -37,13 +37,13 @@ func TestDefaultSize(t *testing.T) { } func TestName(t *testing.T) { - collector := NewCollector(v1alpha1.NewJaeger("TestName")) + collector := NewCollector(v1.NewJaeger("TestName")) dep := collector.Get() assert.Equal(t, "TestName-collector", dep.ObjectMeta.Name) } func TestCollectorServices(t *testing.T) { - collector := NewCollector(v1alpha1.NewJaeger("TestName")) + collector := NewCollector(v1.NewJaeger("TestName")) svcs := collector.Services() assert.Len(t, svcs, 1) } @@ -53,14 +53,14 @@ func TestDefaultCollectorImage(t *testing.T) { viper.Set("jaeger-version", "123") defer viper.Reset() - collector := NewCollector(v1alpha1.NewJaeger("TestCollectorImage")) + collector := NewCollector(v1.NewJaeger("TestCollectorImage")) dep := collector.Get() containers := dep.Spec.Template.Spec.Containers assert.Len(t, containers, 1) assert.Equal(t, "org/custom-collector-image:123", containers[0].Image) - envvars := []v1.EnvVar{ + envvars := []corev1.EnvVar{ { Name: "SPAN_STORAGE_TYPE", Value: "", @@ -74,7 +74,7 @@ func TestDefaultCollectorImage(t *testing.T) { } func TestCollectorAnnotations(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestCollectorAnnotations") + jaeger := v1.NewJaeger("TestCollectorAnnotations") jaeger.Spec.Annotations = map[string]string{ "name": "operator", "hello": "jaeger", @@ -94,7 +94,7 @@ func TestCollectorAnnotations(t *testing.T) { } func TestCollectorSecrets(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestCollectorSecrets") + jaeger := v1.NewJaeger("TestCollectorSecrets") secret := "mysecret" jaeger.Spec.Storage.SecretName = secret @@ -107,33 +107,33 @@ func TestCollectorSecrets(t *testing.T) { func TestCollectorVolumeMountsWithVolumes(t *testing.T) { name := "TestCollectorVolumeMountsWithVolumes" - globalVolumes := []v1.Volume{ + globalVolumes := []corev1.Volume{ { Name: "globalVolume", - VolumeSource: v1.VolumeSource{}, + VolumeSource: corev1.VolumeSource{}, }, } - globalVolumeMounts := []v1.VolumeMount{ + globalVolumeMounts := []corev1.VolumeMount{ { Name: "globalVolume", }, } - collectorVolumes := []v1.Volume{ + collectorVolumes := []corev1.Volume{ { Name: "collectorVolume", - VolumeSource: v1.VolumeSource{}, + VolumeSource: corev1.VolumeSource{}, }, } - collectorVolumeMounts := []v1.VolumeMount{ + collectorVolumeMounts := []corev1.VolumeMount{ { Name: "collectorVolume", }, } - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) jaeger.Spec.Volumes = globalVolumes jaeger.Spec.VolumeMounts = globalVolumeMounts jaeger.Spec.Collector.Volumes = collectorVolumes @@ -154,21 +154,21 @@ func TestCollectorVolumeMountsWithVolumes(t *testing.T) { func TestCollectorMountGlobalVolumes(t *testing.T) { name := "TestCollectorMountGlobalVolumes" - globalVolumes := []v1.Volume{ + globalVolumes := []corev1.Volume{ { Name: "globalVolume", - VolumeSource: v1.VolumeSource{}, + VolumeSource: corev1.VolumeSource{}, }, } - collectorVolumeMounts := []v1.VolumeMount{ + collectorVolumeMounts := []corev1.VolumeMount{ { Name: "globalVolume", ReadOnly: true, }, } - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) jaeger.Spec.Volumes = globalVolumes jaeger.Spec.Collector.VolumeMounts = collectorVolumeMounts podSpec := NewCollector(jaeger).Get().Spec.Template.Spec @@ -182,21 +182,21 @@ func TestCollectorMountGlobalVolumes(t *testing.T) { func TestCollectorVolumeMountsWithSameName(t *testing.T) { name := "TestCollectorVolumeMountsWithSameName" - globalVolumeMounts := []v1.VolumeMount{ + globalVolumeMounts := []corev1.VolumeMount{ { Name: "data", ReadOnly: true, }, } - collectorVolumeMounts := []v1.VolumeMount{ + collectorVolumeMounts := []corev1.VolumeMount{ { Name: "data", ReadOnly: false, }, } - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) jaeger.Spec.VolumeMounts = globalVolumeMounts jaeger.Spec.Collector.VolumeMounts = collectorVolumeMounts podSpec := NewCollector(jaeger).Get().Spec.Template.Spec @@ -210,21 +210,21 @@ func TestCollectorVolumeMountsWithSameName(t *testing.T) { func TestCollectorVolumeWithSameName(t *testing.T) { name := "TestCollectorVolumeWithSameName" - globalVolumes := []v1.Volume{ + globalVolumes := []corev1.Volume{ { Name: "data", - VolumeSource: v1.VolumeSource{HostPath: &v1.HostPathVolumeSource{Path: "/data1"}}, + VolumeSource: corev1.VolumeSource{HostPath: &corev1.HostPathVolumeSource{Path: "/data1"}}, }, } - collectorVolumes := []v1.Volume{ + collectorVolumes := []corev1.Volume{ { Name: "data", - VolumeSource: v1.VolumeSource{HostPath: &v1.HostPathVolumeSource{Path: "/data2"}}, + VolumeSource: corev1.VolumeSource{HostPath: &corev1.HostPathVolumeSource{Path: "/data2"}}, }, } - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) jaeger.Spec.Volumes = globalVolumes jaeger.Spec.Collector.Volumes = collectorVolumes podSpec := NewCollector(jaeger).Get().Spec.Template.Spec @@ -236,41 +236,41 @@ func TestCollectorVolumeWithSameName(t *testing.T) { } func TestCollectorResources(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestCollectorResources") - jaeger.Spec.Resources = v1.ResourceRequirements{ - Limits: v1.ResourceList{ - v1.ResourceLimitsCPU: *resource.NewQuantity(1024, resource.BinarySI), - v1.ResourceLimitsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), + jaeger := v1.NewJaeger("TestCollectorResources") + jaeger.Spec.Resources = corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + corev1.ResourceLimitsCPU: *resource.NewQuantity(1024, resource.BinarySI), + corev1.ResourceLimitsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), }, - Requests: v1.ResourceList{ - v1.ResourceRequestsCPU: *resource.NewQuantity(1024, resource.BinarySI), - v1.ResourceRequestsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), + Requests: corev1.ResourceList{ + corev1.ResourceRequestsCPU: *resource.NewQuantity(1024, resource.BinarySI), + corev1.ResourceRequestsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), }, } - jaeger.Spec.Collector.Resources = v1.ResourceRequirements{ - Limits: v1.ResourceList{ - v1.ResourceLimitsCPU: *resource.NewQuantity(2048, resource.BinarySI), - v1.ResourceLimitsMemory: *resource.NewQuantity(123, resource.DecimalSI), + jaeger.Spec.Collector.Resources = corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + corev1.ResourceLimitsCPU: *resource.NewQuantity(2048, resource.BinarySI), + corev1.ResourceLimitsMemory: *resource.NewQuantity(123, resource.DecimalSI), }, - Requests: v1.ResourceList{ - v1.ResourceRequestsCPU: *resource.NewQuantity(2048, resource.BinarySI), - v1.ResourceRequestsMemory: *resource.NewQuantity(123, resource.DecimalSI), + Requests: corev1.ResourceList{ + corev1.ResourceRequestsCPU: *resource.NewQuantity(2048, resource.BinarySI), + corev1.ResourceRequestsMemory: *resource.NewQuantity(123, resource.DecimalSI), }, } collector := NewCollector(jaeger) dep := collector.Get() - assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[v1.ResourceLimitsCPU]) - assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[v1.ResourceRequestsCPU]) - assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[v1.ResourceLimitsMemory]) - assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[v1.ResourceRequestsMemory]) - assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[v1.ResourceLimitsEphemeralStorage]) - assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[v1.ResourceRequestsEphemeralStorage]) + assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[corev1.ResourceLimitsCPU]) + assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[corev1.ResourceRequestsCPU]) + assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[corev1.ResourceLimitsMemory]) + assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[corev1.ResourceRequestsMemory]) + assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[corev1.ResourceLimitsEphemeralStorage]) + assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[corev1.ResourceRequestsEphemeralStorage]) } func TestCollectorLabels(t *testing.T) { - c := NewCollector(v1alpha1.NewJaeger("TestCollectorLabels")) + c := NewCollector(v1.NewJaeger("TestCollectorLabels")) dep := c.Get() assert.Equal(t, "jaeger-operator", dep.Spec.Template.Labels["app.kubernetes.io/managed-by"]) assert.Equal(t, "collector", dep.Spec.Template.Labels["app.kubernetes.io/component"]) @@ -279,14 +279,14 @@ func TestCollectorLabels(t *testing.T) { } func TestCollectorWithDirectStorageType(t *testing.T) { - jaeger := &v1alpha1.Jaeger{ + jaeger := &v1.Jaeger{ ObjectMeta: metav1.ObjectMeta{ Name: "TestCollectorWithDirectStorageType", }, - Spec: v1alpha1.JaegerSpec{ - Storage: v1alpha1.JaegerStorageSpec{ + Spec: v1.JaegerSpec{ + Storage: v1.JaegerStorageSpec{ Type: "elasticsearch", - Options: v1alpha1.NewOptions(map[string]interface{}{ + Options: v1.NewOptions(map[string]interface{}{ "es.server-urls": "http://somewhere", }), }, @@ -295,7 +295,7 @@ func TestCollectorWithDirectStorageType(t *testing.T) { collector := NewCollector(jaeger) dep := collector.Get() - envvars := []v1.EnvVar{ + envvars := []corev1.EnvVar{ { Name: "SPAN_STORAGE_TYPE", Value: "elasticsearch", @@ -311,20 +311,20 @@ func TestCollectorWithDirectStorageType(t *testing.T) { } func TestCollectorWithIngesterStorageType(t *testing.T) { - jaeger := &v1alpha1.Jaeger{ + jaeger := &v1.Jaeger{ ObjectMeta: metav1.ObjectMeta{ Name: "TestCollectorWithIngesterStorageType", }, - Spec: v1alpha1.JaegerSpec{ + Spec: v1.JaegerSpec{ Strategy: "streaming", - Ingester: v1alpha1.JaegerIngesterSpec{ - Options: v1alpha1.NewOptions(map[string]interface{}{ + Ingester: v1.JaegerIngesterSpec{ + Options: v1.NewOptions(map[string]interface{}{ "kafka.topic": "mytopic", }), }, - Storage: v1alpha1.JaegerStorageSpec{ + Storage: v1.JaegerStorageSpec{ Type: "elasticsearch", - Options: v1alpha1.NewOptions(map[string]interface{}{ + Options: v1.NewOptions(map[string]interface{}{ "kafka.brokers": "http://brokers", "es.server-urls": "http://somewhere", }), @@ -334,7 +334,7 @@ func TestCollectorWithIngesterStorageType(t *testing.T) { collector := NewCollector(jaeger) dep := collector.Get() - envvars := []v1.EnvVar{ + envvars := []corev1.EnvVar{ { Name: "SPAN_STORAGE_TYPE", Value: "kafka", @@ -351,15 +351,15 @@ func TestCollectorWithIngesterStorageType(t *testing.T) { } func TestCollectorWithIngesterNoOptionsStorageType(t *testing.T) { - jaeger := &v1alpha1.Jaeger{ + jaeger := &v1.Jaeger{ ObjectMeta: metav1.ObjectMeta{ Name: "TestCollectorWithIngesterNoOptionsStorageType", }, - Spec: v1alpha1.JaegerSpec{ + Spec: v1.JaegerSpec{ Strategy: "streaming", - Storage: v1alpha1.JaegerStorageSpec{ + Storage: v1.JaegerStorageSpec{ Type: "elasticsearch", - Options: v1alpha1.NewOptions(map[string]interface{}{ + Options: v1.NewOptions(map[string]interface{}{ "kafka.brokers": "http://brokers", "es.server-urls": "http://somewhere", }), @@ -369,7 +369,7 @@ func TestCollectorWithIngesterNoOptionsStorageType(t *testing.T) { collector := NewCollector(jaeger) dep := collector.Get() - envvars := []v1.EnvVar{ + envvars := []corev1.EnvVar{ { Name: "SPAN_STORAGE_TYPE", Value: "kafka", diff --git a/pkg/deployment/ingester.go b/pkg/deployment/ingester.go index 284ee4187..95be6bf52 100644 --- a/pkg/deployment/ingester.go +++ b/pkg/deployment/ingester.go @@ -6,23 +6,23 @@ import ( "github.com/spf13/viper" appsv1 "k8s.io/api/apps/v1" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/intstr" "github.com/jaegertracing/jaeger-operator/pkg/account" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/storage" "github.com/jaegertracing/jaeger-operator/pkg/util" ) // Ingester builds pods for jaegertracing/jaeger-ingester type Ingester struct { - jaeger *v1alpha1.Jaeger + jaeger *v1.Jaeger } // NewIngester builds a new Ingester struct based on the given spec -func NewIngester(jaeger *v1alpha1.Jaeger) *Ingester { +func NewIngester(jaeger *v1.Jaeger) *Ingester { if jaeger.Spec.Ingester.Size <= 0 { jaeger.Spec.Ingester.Size = 1 } @@ -46,7 +46,7 @@ func (i *Ingester) Get() *appsv1.Deployment { trueVar := true replicas := int32(i.jaeger.Spec.Ingester.Size) - baseCommonSpec := v1alpha1.JaegerCommonSpec{ + baseCommonSpec := v1.JaegerCommonSpec{ Annotations: map[string]string{ "prometheus.io/scrape": "true", "prometheus.io/port": "14271", @@ -54,13 +54,13 @@ func (i *Ingester) Get() *appsv1.Deployment { }, } - commonSpec := util.Merge([]v1alpha1.JaegerCommonSpec{i.jaeger.Spec.Ingester.JaegerCommonSpec, i.jaeger.Spec.JaegerCommonSpec, baseCommonSpec}) + commonSpec := util.Merge([]v1.JaegerCommonSpec{i.jaeger.Spec.Ingester.JaegerCommonSpec, i.jaeger.Spec.JaegerCommonSpec, baseCommonSpec}) - var envFromSource []v1.EnvFromSource + var envFromSource []corev1.EnvFromSource if len(i.jaeger.Spec.Storage.SecretName) > 0 { - envFromSource = append(envFromSource, v1.EnvFromSource{ - SecretRef: &v1.SecretEnvSource{ - LocalObjectReference: v1.LocalObjectReference{ + envFromSource = append(envFromSource, corev1.EnvFromSource{ + SecretRef: &corev1.SecretEnvSource{ + LocalObjectReference: corev1.LocalObjectReference{ Name: i.jaeger.Spec.Storage.SecretName, }, }, @@ -95,25 +95,25 @@ func (i *Ingester) Get() *appsv1.Deployment { Selector: &metav1.LabelSelector{ MatchLabels: labels, }, - Template: v1.PodTemplateSpec{ + Template: corev1.PodTemplateSpec{ ObjectMeta: metav1.ObjectMeta{ Labels: labels, Annotations: commonSpec.Annotations, }, - Spec: v1.PodSpec{ - Containers: []v1.Container{{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{{ Image: i.jaeger.Spec.Ingester.Image, Name: "jaeger-ingester", Args: options, - Env: []v1.EnvVar{ - v1.EnvVar{ + Env: []corev1.EnvVar{ + corev1.EnvVar{ Name: "SPAN_STORAGE_TYPE", Value: i.jaeger.Spec.Storage.Type, }, }, VolumeMounts: commonSpec.VolumeMounts, EnvFrom: envFromSource, - Ports: []v1.ContainerPort{ + Ports: []corev1.ContainerPort{ { ContainerPort: 14270, Name: "hc-http", @@ -123,9 +123,9 @@ func (i *Ingester) Get() *appsv1.Deployment { Name: "metrics-http", }, }, - ReadinessProbe: &v1.Probe{ - Handler: v1.Handler{ - HTTPGet: &v1.HTTPGetAction{ + ReadinessProbe: &corev1.Probe{ + Handler: corev1.Handler{ + HTTPGet: &corev1.HTTPGetAction{ Path: "/", Port: intstr.FromInt(14270), }, diff --git a/pkg/deployment/ingester_test.go b/pkg/deployment/ingester_test.go index d2ad32001..7e158e35d 100644 --- a/pkg/deployment/ingester_test.go +++ b/pkg/deployment/ingester_test.go @@ -6,11 +6,11 @@ import ( "github.com/spf13/viper" "github.com/stretchr/testify/assert" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/api/resource" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func init() { @@ -19,7 +19,7 @@ func init() { } func TestIngesterNotDefined(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestIngesterNotDefined") + jaeger := v1.NewJaeger("TestIngesterNotDefined") ingester := NewIngester(jaeger) assert.Nil(t, ingester.Get()) @@ -62,7 +62,7 @@ func TestDefaultIngesterImage(t *testing.T) { assert.Len(t, containers, 1) assert.Equal(t, "org/custom-ingester-image:123", containers[0].Image) - envvars := []v1.EnvVar{ + envvars := []corev1.EnvVar{ { Name: "SPAN_STORAGE_TYPE", Value: "", @@ -105,27 +105,27 @@ func TestIngesterSecrets(t *testing.T) { func TestIngesterVolumeMountsWithVolumes(t *testing.T) { name := "TestIngesterVolumeMountsWithVolumes" - globalVolumes := []v1.Volume{ + globalVolumes := []corev1.Volume{ { Name: "globalVolume", - VolumeSource: v1.VolumeSource{}, + VolumeSource: corev1.VolumeSource{}, }, } - globalVolumeMounts := []v1.VolumeMount{ + globalVolumeMounts := []corev1.VolumeMount{ { Name: "globalVolume", }, } - ingesterVolumes := []v1.Volume{ + ingesterVolumes := []corev1.Volume{ { Name: "ingesterVolume", - VolumeSource: v1.VolumeSource{}, + VolumeSource: corev1.VolumeSource{}, }, } - ingesterVolumeMounts := []v1.VolumeMount{ + ingesterVolumeMounts := []corev1.VolumeMount{ { Name: "ingesterVolume", }, @@ -151,14 +151,14 @@ func TestIngesterVolumeMountsWithVolumes(t *testing.T) { func TestIngesterMountGlobalVolumes(t *testing.T) { name := "TestIngesterMountGlobalVolumes" - globalVolumes := []v1.Volume{ + globalVolumes := []corev1.Volume{ { Name: "globalVolume", - VolumeSource: v1.VolumeSource{}, + VolumeSource: corev1.VolumeSource{}, }, } - ingesterVolumeMounts := []v1.VolumeMount{ + ingesterVolumeMounts := []corev1.VolumeMount{ { Name: "globalVolume", ReadOnly: true, @@ -178,14 +178,14 @@ func TestIngesterMountGlobalVolumes(t *testing.T) { func TestIngesterVolumeMountsWithSameName(t *testing.T) { name := "TestIngesterVolumeMountsWithSameName" - globalVolumeMounts := []v1.VolumeMount{ + globalVolumeMounts := []corev1.VolumeMount{ { Name: "data", ReadOnly: true, }, } - ingesterVolumeMounts := []v1.VolumeMount{ + ingesterVolumeMounts := []corev1.VolumeMount{ { Name: "data", ReadOnly: false, @@ -205,17 +205,17 @@ func TestIngesterVolumeMountsWithSameName(t *testing.T) { func TestIngesterVolumeWithSameName(t *testing.T) { name := "TestIngesterVolumeWithSameName" - globalVolumes := []v1.Volume{ + globalVolumes := []corev1.Volume{ { Name: "data", - VolumeSource: v1.VolumeSource{HostPath: &v1.HostPathVolumeSource{Path: "/data1"}}, + VolumeSource: corev1.VolumeSource{HostPath: &corev1.HostPathVolumeSource{Path: "/data1"}}, }, } - ingesterVolumes := []v1.Volume{ + ingesterVolumes := []corev1.Volume{ { Name: "data", - VolumeSource: v1.VolumeSource{HostPath: &v1.HostPathVolumeSource{Path: "/data2"}}, + VolumeSource: corev1.VolumeSource{HostPath: &corev1.HostPathVolumeSource{Path: "/data2"}}, }, } @@ -231,53 +231,53 @@ func TestIngesterVolumeWithSameName(t *testing.T) { func TestIngesterResources(t *testing.T) { jaeger := newIngesterJaeger("TestIngesterResources") - jaeger.Spec.Resources = v1.ResourceRequirements{ - Limits: v1.ResourceList{ - v1.ResourceLimitsCPU: *resource.NewQuantity(1024, resource.BinarySI), - v1.ResourceLimitsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), + jaeger.Spec.Resources = corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + corev1.ResourceLimitsCPU: *resource.NewQuantity(1024, resource.BinarySI), + corev1.ResourceLimitsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), }, - Requests: v1.ResourceList{ - v1.ResourceRequestsCPU: *resource.NewQuantity(1024, resource.BinarySI), - v1.ResourceRequestsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), + Requests: corev1.ResourceList{ + corev1.ResourceRequestsCPU: *resource.NewQuantity(1024, resource.BinarySI), + corev1.ResourceRequestsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), }, } - jaeger.Spec.Ingester.Resources = v1.ResourceRequirements{ - Limits: v1.ResourceList{ - v1.ResourceLimitsCPU: *resource.NewQuantity(2048, resource.BinarySI), - v1.ResourceLimitsMemory: *resource.NewQuantity(123, resource.DecimalSI), + jaeger.Spec.Ingester.Resources = corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + corev1.ResourceLimitsCPU: *resource.NewQuantity(2048, resource.BinarySI), + corev1.ResourceLimitsMemory: *resource.NewQuantity(123, resource.DecimalSI), }, - Requests: v1.ResourceList{ - v1.ResourceRequestsCPU: *resource.NewQuantity(2048, resource.BinarySI), - v1.ResourceRequestsMemory: *resource.NewQuantity(123, resource.DecimalSI), + Requests: corev1.ResourceList{ + corev1.ResourceRequestsCPU: *resource.NewQuantity(2048, resource.BinarySI), + corev1.ResourceRequestsMemory: *resource.NewQuantity(123, resource.DecimalSI), }, } ingester := NewIngester(jaeger) dep := ingester.Get() - assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[v1.ResourceLimitsCPU]) - assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[v1.ResourceRequestsCPU]) - assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[v1.ResourceLimitsMemory]) - assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[v1.ResourceRequestsMemory]) - assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[v1.ResourceLimitsEphemeralStorage]) - assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[v1.ResourceRequestsEphemeralStorage]) + assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[corev1.ResourceLimitsCPU]) + assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[corev1.ResourceRequestsCPU]) + assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[corev1.ResourceLimitsMemory]) + assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[corev1.ResourceRequestsMemory]) + assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[corev1.ResourceLimitsEphemeralStorage]) + assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[corev1.ResourceRequestsEphemeralStorage]) } func TestIngesterWithStorageType(t *testing.T) { - jaeger := &v1alpha1.Jaeger{ + jaeger := &v1.Jaeger{ ObjectMeta: metav1.ObjectMeta{ Name: "TestIngesterStorageType", }, - Spec: v1alpha1.JaegerSpec{ + Spec: v1.JaegerSpec{ Strategy: "streaming", - Ingester: v1alpha1.JaegerIngesterSpec{ - Options: v1alpha1.NewOptions(map[string]interface{}{ + Ingester: v1.JaegerIngesterSpec{ + Options: v1.NewOptions(map[string]interface{}{ "kafka.topic": "mytopic", }), }, - Storage: v1alpha1.JaegerStorageSpec{ + Storage: v1.JaegerStorageSpec{ Type: "elasticsearch", - Options: v1alpha1.NewOptions(map[string]interface{}{ + Options: v1.NewOptions(map[string]interface{}{ "kafka.brokers": "http://brokers", "es.server-urls": "http://somewhere", }), @@ -287,7 +287,7 @@ func TestIngesterWithStorageType(t *testing.T) { ingester := NewIngester(jaeger) dep := ingester.Get() - envvars := []v1.EnvVar{ + envvars := []corev1.EnvVar{ { Name: "SPAN_STORAGE_TYPE", Value: "elasticsearch", @@ -309,15 +309,15 @@ func TestIngesterLabels(t *testing.T) { assert.Equal(t, fmt.Sprintf("%s-ingester", ingester.jaeger.Name), dep.Spec.Template.Labels["app.kubernetes.io/name"]) } -func newIngesterJaeger(name string) *v1alpha1.Jaeger { - return &v1alpha1.Jaeger{ +func newIngesterJaeger(name string) *v1.Jaeger { + return &v1.Jaeger{ ObjectMeta: metav1.ObjectMeta{ Name: name, }, - Spec: v1alpha1.JaegerSpec{ + Spec: v1.JaegerSpec{ Strategy: "streaming", - Ingester: v1alpha1.JaegerIngesterSpec{ - Options: v1alpha1.NewOptions(map[string]interface{}{ + Ingester: v1.JaegerIngesterSpec{ + Options: v1.NewOptions(map[string]interface{}{ "any": "option", }), }, diff --git a/pkg/deployment/query.go b/pkg/deployment/query.go index 25a6ebd9e..1d95bf745 100644 --- a/pkg/deployment/query.go +++ b/pkg/deployment/query.go @@ -5,12 +5,12 @@ import ( "github.com/spf13/viper" appsv1 "k8s.io/api/apps/v1" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/intstr" "github.com/jaegertracing/jaeger-operator/pkg/account" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/config/ui" "github.com/jaegertracing/jaeger-operator/pkg/service" "github.com/jaegertracing/jaeger-operator/pkg/storage" @@ -19,11 +19,11 @@ import ( // Query builds pods for jaegertracing/jaeger-query type Query struct { - jaeger *v1alpha1.Jaeger + jaeger *v1.Jaeger } // NewQuery builds a new Query struct based on the given spec -func NewQuery(jaeger *v1alpha1.Jaeger) *Query { +func NewQuery(jaeger *v1.Jaeger) *Query { if jaeger.Spec.Query.Size <= 0 { jaeger.Spec.Query.Size = 1 } @@ -42,7 +42,7 @@ func (q *Query) Get() *appsv1.Deployment { trueVar := true replicas := int32(q.jaeger.Spec.Query.Size) - baseCommonSpec := v1alpha1.JaegerCommonSpec{ + baseCommonSpec := v1.JaegerCommonSpec{ Annotations: map[string]string{ "prometheus.io/scrape": "true", "prometheus.io/port": "16686", @@ -57,17 +57,17 @@ func (q *Query) Get() *appsv1.Deployment { }, } - commonSpec := util.Merge([]v1alpha1.JaegerCommonSpec{q.jaeger.Spec.Query.JaegerCommonSpec, q.jaeger.Spec.JaegerCommonSpec, baseCommonSpec}) + commonSpec := util.Merge([]v1.JaegerCommonSpec{q.jaeger.Spec.Query.JaegerCommonSpec, q.jaeger.Spec.JaegerCommonSpec, baseCommonSpec}) options := allArgs(q.jaeger.Spec.Query.Options, q.jaeger.Spec.Storage.Options.Filter(storage.OptionsPrefix(q.jaeger.Spec.Storage.Type))) configmap.Update(q.jaeger, commonSpec, &options) - var envFromSource []v1.EnvFromSource + var envFromSource []corev1.EnvFromSource if len(q.jaeger.Spec.Storage.SecretName) > 0 { - envFromSource = append(envFromSource, v1.EnvFromSource{ - SecretRef: &v1.SecretEnvSource{ - LocalObjectReference: v1.LocalObjectReference{ + envFromSource = append(envFromSource, corev1.EnvFromSource{ + SecretRef: &corev1.SecretEnvSource{ + LocalObjectReference: corev1.LocalObjectReference{ Name: q.jaeger.Spec.Storage.SecretName, }, }, @@ -99,33 +99,33 @@ func (q *Query) Get() *appsv1.Deployment { Selector: &metav1.LabelSelector{ MatchLabels: labels, }, - Template: v1.PodTemplateSpec{ + Template: corev1.PodTemplateSpec{ ObjectMeta: metav1.ObjectMeta{ Labels: labels, Annotations: commonSpec.Annotations, }, - Spec: v1.PodSpec{ - Containers: []v1.Container{{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{{ Image: q.jaeger.Spec.Query.Image, Name: "jaeger-query", Args: options, - Env: []v1.EnvVar{ - v1.EnvVar{ + Env: []corev1.EnvVar{ + corev1.EnvVar{ Name: "SPAN_STORAGE_TYPE", Value: q.jaeger.Spec.Storage.Type, }, }, VolumeMounts: commonSpec.VolumeMounts, EnvFrom: envFromSource, - Ports: []v1.ContainerPort{ + Ports: []corev1.ContainerPort{ { ContainerPort: 16686, Name: "query", }, }, - ReadinessProbe: &v1.Probe{ - Handler: v1.Handler{ - HTTPGet: &v1.HTTPGetAction{ + ReadinessProbe: &corev1.Probe{ + Handler: corev1.Handler{ + HTTPGet: &corev1.HTTPGetAction{ Path: "/", Port: intstr.FromInt(16687), }, @@ -143,9 +143,9 @@ func (q *Query) Get() *appsv1.Deployment { } // Services returns a list of services to be deployed along with the query deployment -func (q *Query) Services() []*v1.Service { +func (q *Query) Services() []*corev1.Service { labels := q.labels() - return []*v1.Service{ + return []*corev1.Service{ service.NewQueryService(q.jaeger, labels), } } diff --git a/pkg/deployment/query_test.go b/pkg/deployment/query_test.go index a6dedaf8f..6133a7250 100644 --- a/pkg/deployment/query_test.go +++ b/pkg/deployment/query_test.go @@ -6,10 +6,10 @@ import ( "github.com/spf13/viper" "github.com/stretchr/testify/assert" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/api/resource" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func init() { @@ -18,7 +18,7 @@ func init() { } func TestQueryNegativeSize(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestQueryNegativeSize") + jaeger := v1.NewJaeger("TestQueryNegativeSize") jaeger.Spec.Query.Size = -1 query := NewQuery(jaeger) @@ -27,7 +27,7 @@ func TestQueryNegativeSize(t *testing.T) { } func TestQueryDefaultSize(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestQueryDefaultSize") + jaeger := v1.NewJaeger("TestQueryDefaultSize") jaeger.Spec.Query.Size = 0 query := NewQuery(jaeger) @@ -40,7 +40,7 @@ func TestDefaultQueryImage(t *testing.T) { viper.Set("jaeger-version", "123") defer viper.Reset() - query := NewQuery(v1alpha1.NewJaeger("TestQueryImage")) + query := NewQuery(v1.NewJaeger("TestQueryImage")) dep := query.Get() containers := dep.Spec.Template.Spec.Containers @@ -49,7 +49,7 @@ func TestDefaultQueryImage(t *testing.T) { } func TestQueryAnnotations(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestQueryAnnotations") + jaeger := v1.NewJaeger("TestQueryAnnotations") jaeger.Spec.Annotations = map[string]string{ "name": "operator", "hello": "jaeger", @@ -69,7 +69,7 @@ func TestQueryAnnotations(t *testing.T) { } func TestQuerySecrets(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestQuerySecrets") + jaeger := v1.NewJaeger("TestQuerySecrets") secret := "mysecret" jaeger.Spec.Storage.SecretName = secret @@ -81,14 +81,14 @@ func TestQuerySecrets(t *testing.T) { func TestQueryPodName(t *testing.T) { name := "TestQueryPodName" - query := NewQuery(v1alpha1.NewJaeger(name)) + query := NewQuery(v1.NewJaeger(name)) dep := query.Get() assert.Contains(t, dep.ObjectMeta.Name, fmt.Sprintf("%s-query", name)) } func TestQueryServices(t *testing.T) { - query := NewQuery(v1alpha1.NewJaeger("TestQueryServices")) + query := NewQuery(v1.NewJaeger("TestQueryServices")) svcs := query.Services() assert.Len(t, svcs, 1) @@ -97,33 +97,33 @@ func TestQueryServices(t *testing.T) { func TestQueryVolumeMountsWithVolumes(t *testing.T) { name := "TestQueryVolumeMountsWithVolumes" - globalVolumes := []v1.Volume{ + globalVolumes := []corev1.Volume{ { Name: "globalVolume", - VolumeSource: v1.VolumeSource{}, + VolumeSource: corev1.VolumeSource{}, }, } - globalVolumeMounts := []v1.VolumeMount{ + globalVolumeMounts := []corev1.VolumeMount{ { Name: "globalVolume", }, } - queryVolumes := []v1.Volume{ + queryVolumes := []corev1.Volume{ { Name: "queryVolume", - VolumeSource: v1.VolumeSource{}, + VolumeSource: corev1.VolumeSource{}, }, } - queryVolumeMounts := []v1.VolumeMount{ + queryVolumeMounts := []corev1.VolumeMount{ { Name: "queryVolume", }, } - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) jaeger.Spec.Volumes = globalVolumes jaeger.Spec.VolumeMounts = globalVolumeMounts jaeger.Spec.Query.Volumes = queryVolumes @@ -143,21 +143,21 @@ func TestQueryVolumeMountsWithVolumes(t *testing.T) { func TestQueryMountGlobalVolumes(t *testing.T) { name := "TestQueryMountGlobalVolumes" - globalVolumes := []v1.Volume{ + globalVolumes := []corev1.Volume{ { Name: "globalVolume", - VolumeSource: v1.VolumeSource{}, + VolumeSource: corev1.VolumeSource{}, }, } - queryVolumeMounts := []v1.VolumeMount{ + queryVolumeMounts := []corev1.VolumeMount{ { Name: "globalVolume", ReadOnly: true, }, } - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) jaeger.Spec.Volumes = globalVolumes jaeger.Spec.Query.VolumeMounts = queryVolumeMounts podSpec := NewQuery(jaeger).Get().Spec.Template.Spec @@ -170,21 +170,21 @@ func TestQueryMountGlobalVolumes(t *testing.T) { func TestQueryVolumeMountsWithSameName(t *testing.T) { name := "TestQueryVolumeMountsWithSameName" - globalVolumeMounts := []v1.VolumeMount{ + globalVolumeMounts := []corev1.VolumeMount{ { Name: "data", ReadOnly: true, }, } - queryVolumeMounts := []v1.VolumeMount{ + queryVolumeMounts := []corev1.VolumeMount{ { Name: "data", ReadOnly: false, }, } - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) jaeger.Spec.VolumeMounts = globalVolumeMounts jaeger.Spec.Query.VolumeMounts = queryVolumeMounts podSpec := NewQuery(jaeger).Get().Spec.Template.Spec @@ -197,21 +197,21 @@ func TestQueryVolumeMountsWithSameName(t *testing.T) { func TestQueryVolumeWithSameName(t *testing.T) { name := "TestQueryVolumeWithSameName" - globalVolumes := []v1.Volume{ + globalVolumes := []corev1.Volume{ { Name: "data", - VolumeSource: v1.VolumeSource{HostPath: &v1.HostPathVolumeSource{Path: "/data1"}}, + VolumeSource: corev1.VolumeSource{HostPath: &corev1.HostPathVolumeSource{Path: "/data1"}}, }, } - queryVolumes := []v1.Volume{ + queryVolumes := []corev1.Volume{ { Name: "data", - VolumeSource: v1.VolumeSource{HostPath: &v1.HostPathVolumeSource{Path: "/data2"}}, + VolumeSource: corev1.VolumeSource{HostPath: &corev1.HostPathVolumeSource{Path: "/data2"}}, }, } - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) jaeger.Spec.Volumes = globalVolumes jaeger.Spec.Query.Volumes = queryVolumes podSpec := NewQuery(jaeger).Get().Spec.Template.Spec @@ -222,41 +222,41 @@ func TestQueryVolumeWithSameName(t *testing.T) { } func TestQueryResources(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestQueryResources") - jaeger.Spec.Resources = v1.ResourceRequirements{ - Limits: v1.ResourceList{ - v1.ResourceLimitsCPU: *resource.NewQuantity(1024, resource.BinarySI), - v1.ResourceLimitsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), + jaeger := v1.NewJaeger("TestQueryResources") + jaeger.Spec.Resources = corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + corev1.ResourceLimitsCPU: *resource.NewQuantity(1024, resource.BinarySI), + corev1.ResourceLimitsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), }, - Requests: v1.ResourceList{ - v1.ResourceRequestsCPU: *resource.NewQuantity(1024, resource.BinarySI), - v1.ResourceRequestsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), + Requests: corev1.ResourceList{ + corev1.ResourceRequestsCPU: *resource.NewQuantity(1024, resource.BinarySI), + corev1.ResourceRequestsEphemeralStorage: *resource.NewQuantity(512, resource.DecimalSI), }, } - jaeger.Spec.Query.Resources = v1.ResourceRequirements{ - Limits: v1.ResourceList{ - v1.ResourceLimitsCPU: *resource.NewQuantity(2048, resource.BinarySI), - v1.ResourceLimitsMemory: *resource.NewQuantity(123, resource.DecimalSI), + jaeger.Spec.Query.Resources = corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + corev1.ResourceLimitsCPU: *resource.NewQuantity(2048, resource.BinarySI), + corev1.ResourceLimitsMemory: *resource.NewQuantity(123, resource.DecimalSI), }, - Requests: v1.ResourceList{ - v1.ResourceRequestsCPU: *resource.NewQuantity(2048, resource.BinarySI), - v1.ResourceRequestsMemory: *resource.NewQuantity(123, resource.DecimalSI), + Requests: corev1.ResourceList{ + corev1.ResourceRequestsCPU: *resource.NewQuantity(2048, resource.BinarySI), + corev1.ResourceRequestsMemory: *resource.NewQuantity(123, resource.DecimalSI), }, } query := NewQuery(jaeger) dep := query.Get() - assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[v1.ResourceLimitsCPU]) - assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[v1.ResourceRequestsCPU]) - assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[v1.ResourceLimitsMemory]) - assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[v1.ResourceRequestsMemory]) - assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[v1.ResourceLimitsEphemeralStorage]) - assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[v1.ResourceRequestsEphemeralStorage]) + assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[corev1.ResourceLimitsCPU]) + assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[corev1.ResourceRequestsCPU]) + assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[corev1.ResourceLimitsMemory]) + assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[corev1.ResourceRequestsMemory]) + assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Limits[corev1.ResourceLimitsEphemeralStorage]) + assert.Equal(t, *resource.NewQuantity(512, resource.DecimalSI), dep.Spec.Template.Spec.Containers[0].Resources.Requests[corev1.ResourceRequestsEphemeralStorage]) } func TestQueryLabels(t *testing.T) { - query := NewQuery(v1alpha1.NewJaeger("TestQueryLabels")) + query := NewQuery(v1.NewJaeger("TestQueryLabels")) dep := query.Get() assert.Equal(t, "jaeger-operator", dep.Spec.Template.Labels["app.kubernetes.io/managed-by"]) assert.Equal(t, "query", dep.Spec.Template.Labels["app.kubernetes.io/component"]) diff --git a/pkg/ingress/query.go b/pkg/ingress/query.go index 6b0b6ef7d..be4650b02 100644 --- a/pkg/ingress/query.go +++ b/pkg/ingress/query.go @@ -4,37 +4,37 @@ import ( "fmt" "strings" - "k8s.io/api/extensions/v1beta1" + extv1beta1 "k8s.io/api/extensions/v1beta1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/intstr" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/service" "github.com/jaegertracing/jaeger-operator/pkg/util" ) // QueryIngress builds pods for jaegertracing/jaeger-query type QueryIngress struct { - jaeger *v1alpha1.Jaeger + jaeger *v1.Jaeger } // NewQueryIngress builds a new QueryIngress struct based on the given spec -func NewQueryIngress(jaeger *v1alpha1.Jaeger) *QueryIngress { +func NewQueryIngress(jaeger *v1.Jaeger) *QueryIngress { return &QueryIngress{jaeger: jaeger} } // Get returns an ingress specification for the current instance -func (i *QueryIngress) Get() *v1beta1.Ingress { +func (i *QueryIngress) Get() *extv1beta1.Ingress { if i.jaeger.Spec.Ingress.Enabled != nil && *i.jaeger.Spec.Ingress.Enabled == false { return nil } trueVar := true - commonSpec := util.Merge([]v1alpha1.JaegerCommonSpec{i.jaeger.Spec.Ingress.JaegerCommonSpec, i.jaeger.Spec.JaegerCommonSpec}) + commonSpec := util.Merge([]v1.JaegerCommonSpec{i.jaeger.Spec.Ingress.JaegerCommonSpec, i.jaeger.Spec.JaegerCommonSpec}) - spec := v1beta1.IngressSpec{} - backend := v1beta1.IngressBackend{ + spec := extv1beta1.IngressSpec{} + backend := extv1beta1.IngressBackend{ ServiceName: service.GetNameForQueryService(i.jaeger), ServicePort: intstr.FromInt(service.GetPortForQueryService(i.jaeger)), } @@ -46,7 +46,7 @@ func (i *QueryIngress) Get() *v1beta1.Ingress { spec.Backend = &backend } - return &v1beta1.Ingress{ + return &extv1beta1.Ingress{ TypeMeta: metav1.TypeMeta{ Kind: "Ingress", APIVersion: "extensions/v1beta1", @@ -77,11 +77,11 @@ func (i *QueryIngress) Get() *v1beta1.Ingress { } } -func getRule(options v1alpha1.Options, backend v1beta1.IngressBackend) v1beta1.IngressRule { - rule := v1beta1.IngressRule{} - rule.HTTP = &v1beta1.HTTPIngressRuleValue{ - Paths: []v1beta1.HTTPIngressPath{ - v1beta1.HTTPIngressPath{ +func getRule(options v1.Options, backend extv1beta1.IngressBackend) extv1beta1.IngressRule { + rule := extv1beta1.IngressRule{} + rule.HTTP = &extv1beta1.HTTPIngressRuleValue{ + Paths: []extv1beta1.HTTPIngressPath{ + extv1beta1.HTTPIngressPath{ Path: options.Map()["query.base-path"], Backend: backend, }, diff --git a/pkg/ingress/query_test.go b/pkg/ingress/query_test.go index a1610388e..58c48c202 100644 --- a/pkg/ingress/query_test.go +++ b/pkg/ingress/query_test.go @@ -6,12 +6,12 @@ import ( "github.com/stretchr/testify/assert" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestQueryIngress(t *testing.T) { name := "TestQueryIngress" - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) ingress := NewQueryIngress(jaeger) dep := ingress.Get() @@ -22,7 +22,7 @@ func TestQueryIngress(t *testing.T) { func TestQueryIngressDisabled(t *testing.T) { enabled := false name := "TestQueryIngressDisabled" - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) jaeger.Spec.Ingress.Enabled = &enabled ingress := NewQueryIngress(jaeger) @@ -34,7 +34,7 @@ func TestQueryIngressDisabled(t *testing.T) { func TestQueryIngressEnabled(t *testing.T) { enabled := true name := "TestQueryIngressEnabled" - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) jaeger.Spec.Ingress.Enabled = &enabled ingress := NewQueryIngress(jaeger) @@ -47,10 +47,10 @@ func TestQueryIngressEnabled(t *testing.T) { func TestQueryIngressAllInOneBasePath(t *testing.T) { enabled := true name := "TestQueryIngressAllInOneBasePath" - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) jaeger.Spec.Ingress.Enabled = &enabled jaeger.Spec.Strategy = "allInOne" - jaeger.Spec.AllInOne.Options = v1alpha1.NewOptions(map[string]interface{}{"query.base-path": "/jaeger"}) + jaeger.Spec.AllInOne.Options = v1.NewOptions(map[string]interface{}{"query.base-path": "/jaeger"}) ingress := NewQueryIngress(jaeger) dep := ingress.Get() @@ -66,10 +66,10 @@ func TestQueryIngressAllInOneBasePath(t *testing.T) { func TestQueryIngressQueryBasePath(t *testing.T) { enabled := true name := "TestQueryIngressQueryBasePath" - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) jaeger.Spec.Ingress.Enabled = &enabled jaeger.Spec.Strategy = "production" - jaeger.Spec.Query.Options = v1alpha1.NewOptions(map[string]interface{}{"query.base-path": "/jaeger"}) + jaeger.Spec.Query.Options = v1.NewOptions(map[string]interface{}{"query.base-path": "/jaeger"}) ingress := NewQueryIngress(jaeger) dep := ingress.Get() @@ -83,7 +83,7 @@ func TestQueryIngressQueryBasePath(t *testing.T) { } func TestQueryIngressAnnotations(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestQueryIngressAnnotations") + jaeger := v1.NewJaeger("TestQueryIngressAnnotations") jaeger.Spec.Annotations = map[string]string{ "name": "operator", "hello": "jaeger", diff --git a/pkg/inject/oauth-proxy.go b/pkg/inject/oauth-proxy.go index 8136f5746..3ffcf420c 100644 --- a/pkg/inject/oauth-proxy.go +++ b/pkg/inject/oauth-proxy.go @@ -5,25 +5,25 @@ import ( "github.com/spf13/viper" appsv1 "k8s.io/api/apps/v1" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" "github.com/jaegertracing/jaeger-operator/pkg/account" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/service" ) // OAuthProxy injects an appropriate proxy into the given deployment -func OAuthProxy(jaeger *v1alpha1.Jaeger, dep *appsv1.Deployment) *appsv1.Deployment { - if jaeger.Spec.Ingress.Security != v1alpha1.IngressSecurityOAuthProxy { +func OAuthProxy(jaeger *v1.Jaeger, dep *appsv1.Deployment) *appsv1.Deployment { + if jaeger.Spec.Ingress.Security != v1.IngressSecurityOAuthProxy { return dep } dep.Spec.Template.Spec.ServiceAccountName = account.OAuthProxyAccountNameFor(jaeger) dep.Spec.Template.Spec.Containers = append(dep.Spec.Template.Spec.Containers, getOAuthProxyContainer(jaeger)) - dep.Spec.Template.Spec.Volumes = append(dep.Spec.Template.Spec.Volumes, v1.Volume{ + dep.Spec.Template.Spec.Volumes = append(dep.Spec.Template.Spec.Volumes, corev1.Volume{ Name: service.GetTLSSecretNameForQueryService(jaeger), - VolumeSource: v1.VolumeSource{ - Secret: &v1.SecretVolumeSource{ + VolumeSource: corev1.VolumeSource{ + Secret: &corev1.SecretVolumeSource{ SecretName: service.GetTLSSecretNameForQueryService(jaeger), }, }, @@ -31,8 +31,8 @@ func OAuthProxy(jaeger *v1alpha1.Jaeger, dep *appsv1.Deployment) *appsv1.Deploym return dep } -func getOAuthProxyContainer(jaeger *v1alpha1.Jaeger) v1.Container { - return v1.Container{ +func getOAuthProxyContainer(jaeger *v1.Jaeger) corev1.Container { + return corev1.Container{ Image: viper.GetString("openshift-oauth-proxy-image"), Name: "oauth-proxy", Args: []string{ @@ -44,11 +44,11 @@ func getOAuthProxyContainer(jaeger *v1alpha1.Jaeger) v1.Container { "--tls-key=/etc/tls/private/tls.key", "--cookie-secret=SECRET", }, - VolumeMounts: []v1.VolumeMount{{ + VolumeMounts: []corev1.VolumeMount{{ MountPath: "/etc/tls/private", Name: service.GetTLSSecretNameForQueryService(jaeger), }}, - Ports: []v1.ContainerPort{ + Ports: []corev1.ContainerPort{ { ContainerPort: 8443, Name: "public", diff --git a/pkg/inject/oauth-proxy_test.go b/pkg/inject/oauth-proxy_test.go index 9d9c6021c..a39fc60ca 100644 --- a/pkg/inject/oauth-proxy_test.go +++ b/pkg/inject/oauth-proxy_test.go @@ -6,44 +6,44 @@ import ( "github.com/stretchr/testify/assert" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/deployment" "github.com/jaegertracing/jaeger-operator/pkg/service" ) func TestOAuthProxyContainerIsNotAddedByDefault(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestOAuthProxyContainerIsNotAddedByDefault") + jaeger := v1.NewJaeger("TestOAuthProxyContainerIsNotAddedByDefault") dep := OAuthProxy(jaeger, deployment.NewQuery(jaeger).Get()) assert.Len(t, dep.Spec.Template.Spec.Containers, 1) assert.Equal(t, "jaeger-query", dep.Spec.Template.Spec.Containers[0].Name) } func TestOAuthProxyContainerIsAdded(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestOAuthProxyContainerIsAdded") - jaeger.Spec.Ingress.Security = v1alpha1.IngressSecurityOAuthProxy + jaeger := v1.NewJaeger("TestOAuthProxyContainerIsAdded") + jaeger.Spec.Ingress.Security = v1.IngressSecurityOAuthProxy dep := OAuthProxy(jaeger, deployment.NewQuery(jaeger).Get()) assert.Len(t, dep.Spec.Template.Spec.Containers, 2) assert.Equal(t, "oauth-proxy", dep.Spec.Template.Spec.Containers[1].Name) } func TestOAuthProxyTLSSecretVolumeIsAdded(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestOAuthProxyTLSSecretVolumeIsAdded") - jaeger.Spec.Ingress.Security = v1alpha1.IngressSecurityOAuthProxy + jaeger := v1.NewJaeger("TestOAuthProxyTLSSecretVolumeIsAdded") + jaeger.Spec.Ingress.Security = v1.IngressSecurityOAuthProxy dep := OAuthProxy(jaeger, deployment.NewQuery(jaeger).Get()) assert.Len(t, dep.Spec.Template.Spec.Volumes, 1) assert.Equal(t, dep.Spec.Template.Spec.Volumes[0].Name, service.GetTLSSecretNameForQueryService(jaeger)) } func TestOAuthProxyTLSSecretVolumeIsNotAddedByDefault(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestOAuthProxyTLSSecretVolumeIsNotAddedByDefault") + jaeger := v1.NewJaeger("TestOAuthProxyTLSSecretVolumeIsNotAddedByDefault") dep := OAuthProxy(jaeger, deployment.NewQuery(jaeger).Get()) assert.Len(t, dep.Spec.Template.Spec.Volumes, 0) } func TestOAuthProxyConsistentServiceAccountName(t *testing.T) { // see https://github.com/openshift/oauth-proxy/issues/95 - jaeger := v1alpha1.NewJaeger("TestOAuthProxyConsistentServiceAccountName") - jaeger.Spec.Ingress.Security = v1alpha1.IngressSecurityOAuthProxy + jaeger := v1.NewJaeger("TestOAuthProxyConsistentServiceAccountName") + jaeger.Spec.Ingress.Security = v1.IngressSecurityOAuthProxy dep := OAuthProxy(jaeger, deployment.NewQuery(jaeger).Get()) found := false diff --git a/pkg/inject/sidecar.go b/pkg/inject/sidecar.go index 9f9b07298..1bee63ce1 100644 --- a/pkg/inject/sidecar.go +++ b/pkg/inject/sidecar.go @@ -6,9 +6,9 @@ import ( log "github.com/sirupsen/logrus" appsv1 "k8s.io/api/apps/v1" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/deployment" "github.com/jaegertracing/jaeger-operator/pkg/service" ) @@ -27,7 +27,7 @@ const ( ) // Sidecar adds a new container to the deployment, connecting to the given jaeger instance -func Sidecar(jaeger *v1alpha1.Jaeger, dep *appsv1.Deployment) *appsv1.Deployment { +func Sidecar(jaeger *v1.Jaeger, dep *appsv1.Deployment) *appsv1.Deployment { deployment.NewAgent(jaeger) // we need some initialization from that, but we don't actually need the agent's instance here logFields := jaeger.Logger().WithField("deployment", dep.Name) @@ -64,7 +64,7 @@ func Needed(dep *appsv1.Deployment) bool { } // Select a suitable Jaeger from the JaegerList for the given Pod, or nil of none is suitable -func Select(target *appsv1.Deployment, availableJaegerPods *v1alpha1.JaegerList) *v1alpha1.Jaeger { +func Select(target *appsv1.Deployment, availableJaegerPods *v1.JaegerList) *v1.Jaeger { jaegerName := target.Annotations[Annotation] if strings.EqualFold(jaegerName, "true") && len(availableJaegerPods.Items) == 1 { // if there's only *one* jaeger within this namespace, then that's what @@ -85,13 +85,13 @@ func Select(target *appsv1.Deployment, availableJaegerPods *v1alpha1.JaegerList) return nil } -func container(jaeger *v1alpha1.Jaeger) v1.Container { +func container(jaeger *v1.Jaeger) corev1.Container { args := append(jaeger.Spec.Agent.Options.ToArgs(), fmt.Sprintf("--collector.host-port=%s.%s:14267", service.GetNameForCollectorService(jaeger), jaeger.Namespace)) - return v1.Container{ + return corev1.Container{ Image: jaeger.Spec.Agent.Image, Name: "jaeger-agent", Args: args, - Ports: []v1.ContainerPort{ + Ports: []corev1.ContainerPort{ { ContainerPort: 5775, Name: "zk-compact-trft", @@ -123,13 +123,13 @@ func decorate(dep *appsv1.Deployment) { } for i := 0; i < len(dep.Spec.Template.Spec.Containers); i++ { if !hasEnv(envVarServiceName, dep.Spec.Template.Spec.Containers[i].Env) { - dep.Spec.Template.Spec.Containers[i].Env = append(dep.Spec.Template.Spec.Containers[i].Env, v1.EnvVar{ + dep.Spec.Template.Spec.Containers[i].Env = append(dep.Spec.Template.Spec.Containers[i].Env, corev1.EnvVar{ Name: envVarServiceName, Value: app, }) } if !hasEnv(envVarPropagation, dep.Spec.Template.Spec.Containers[i].Env) { - dep.Spec.Template.Spec.Containers[i].Env = append(dep.Spec.Template.Spec.Containers[i].Env, v1.EnvVar{ + dep.Spec.Template.Spec.Containers[i].Env = append(dep.Spec.Template.Spec.Containers[i].Env, corev1.EnvVar{ Name: envVarPropagation, Value: "jaeger,b3", }) @@ -138,7 +138,7 @@ func decorate(dep *appsv1.Deployment) { } } -func hasEnv(name string, vars []v1.EnvVar) bool { +func hasEnv(name string, vars []corev1.EnvVar) bool { for i := 0; i < len(vars); i++ { if vars[i].Name == name { return true diff --git a/pkg/inject/sidecar_test.go b/pkg/inject/sidecar_test.go index 43c41ea39..7ae3ef2df 100644 --- a/pkg/inject/sidecar_test.go +++ b/pkg/inject/sidecar_test.go @@ -6,10 +6,10 @@ import ( "github.com/spf13/viper" "github.com/stretchr/testify/assert" appsv1 "k8s.io/api/apps/v1" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func setDefaults() { @@ -27,7 +27,7 @@ func reset() { } func TestInjectSidecar(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestInjectSidecar") + jaeger := v1.NewJaeger("TestInjectSidecar") dep := dep(map[string]string{Annotation: jaeger.Name}, map[string]string{}) dep = Sidecar(jaeger, dep) assert.Len(t, dep.Spec.Template.Spec.Containers, 2) @@ -36,7 +36,7 @@ func TestInjectSidecar(t *testing.T) { } func TestInjectSidecarWithLegacyAnnotation(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestInjectSidecarWithLegacyAnnotation") + jaeger := v1.NewJaeger("TestInjectSidecarWithLegacyAnnotation") dep := dep(map[string]string{AnnotationLegacy: jaeger.Name}, map[string]string{}) dep = Sidecar(jaeger, dep) assert.Len(t, dep.Spec.Template.Spec.Containers, 2) @@ -45,7 +45,7 @@ func TestInjectSidecarWithLegacyAnnotation(t *testing.T) { } func TestInjectSidecarWithEnvVars(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestInjectSidecarWithEnvVars") + jaeger := v1.NewJaeger("TestInjectSidecarWithEnvVars") dep := dep(map[string]string{Annotation: jaeger.Name}, map[string]string{"app": "testapp"}) dep = Sidecar(jaeger, dep) assert.Len(t, dep.Spec.Template.Spec.Containers, 2) @@ -58,7 +58,7 @@ func TestInjectSidecarWithEnvVars(t *testing.T) { } func TestInjectSidecarWithEnvVarsWithNamespace(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestInjectSidecarWithEnvVarsWithNamespace") + jaeger := v1.NewJaeger("TestInjectSidecarWithEnvVarsWithNamespace") dep := dep(map[string]string{Annotation: jaeger.Name}, map[string]string{"app": "testapp"}) dep.Namespace = "mynamespace" dep = Sidecar(jaeger, dep) @@ -72,9 +72,9 @@ func TestInjectSidecarWithEnvVarsWithNamespace(t *testing.T) { } func TestInjectSidecarWithEnvVarsOverrideName(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestInjectSidecarWithEnvVarsOverrideName") + jaeger := v1.NewJaeger("TestInjectSidecarWithEnvVarsOverrideName") dep := dep(map[string]string{Annotation: jaeger.Name}, map[string]string{"app": "testapp"}) - dep.Spec.Template.Spec.Containers[0].Env = append(dep.Spec.Template.Spec.Containers[0].Env, v1.EnvVar{ + dep.Spec.Template.Spec.Containers[0].Env = append(dep.Spec.Template.Spec.Containers[0].Env, corev1.EnvVar{ Name: envVarServiceName, Value: "otherapp", }) @@ -90,9 +90,9 @@ func TestInjectSidecarWithEnvVarsOverrideName(t *testing.T) { } func TestInjectSidecarWithEnvVarsOverridePropagation(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestInjectSidecarWithEnvVarsOverridePropagation") + jaeger := v1.NewJaeger("TestInjectSidecarWithEnvVarsOverridePropagation") dep := dep(map[string]string{Annotation: jaeger.Name}, map[string]string{"app": "testapp"}) - dep.Spec.Template.Spec.Containers[0].Env = append(dep.Spec.Template.Spec.Containers[0].Env, v1.EnvVar{ + dep.Spec.Template.Spec.Containers[0].Env = append(dep.Spec.Template.Spec.Containers[0].Env, corev1.EnvVar{ Name: envVarPropagation, Value: "tracecontext", }) @@ -108,7 +108,7 @@ func TestInjectSidecarWithEnvVarsOverridePropagation(t *testing.T) { } func TestSkipInjectSidecar(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestSkipInjectSidecar") + jaeger := v1.NewJaeger("TestSkipInjectSidecar") dep := dep(map[string]string{Annotation: "non-existing-operator"}, map[string]string{}) dep = Sidecar(jaeger, dep) assert.Len(t, dep.Spec.Template.Spec.Containers, 1) @@ -118,10 +118,10 @@ func TestSkipInjectSidecar(t *testing.T) { func TestSidecarNotNeeded(t *testing.T) { dep := &appsv1.Deployment{ Spec: appsv1.DeploymentSpec{ - Template: v1.PodTemplateSpec{ - Spec: v1.PodSpec{ - Containers: []v1.Container{ - v1.Container{}, + Template: corev1.PodTemplateSpec{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + corev1.Container{}, }, }, }, @@ -139,16 +139,16 @@ func TestSidecarNeeded(t *testing.T) { func TestHasSidecarAlready(t *testing.T) { dep := dep(map[string]string{Annotation: "TestHasSidecarAlready"}, map[string]string{}) assert.True(t, Needed(dep)) - jaeger := v1alpha1.NewJaeger("TestHasSidecarAlready") + jaeger := v1.NewJaeger("TestHasSidecarAlready") dep = Sidecar(jaeger, dep) assert.False(t, Needed(dep)) } func TestSelectSingleJaegerPod(t *testing.T) { dep := dep(map[string]string{Annotation: "true"}, map[string]string{}) - jaegerPods := &v1alpha1.JaegerList{ - Items: []v1alpha1.Jaeger{ - v1alpha1.Jaeger{ + jaegerPods := &v1.JaegerList{ + Items: []v1.Jaeger{ + v1.Jaeger{ ObjectMeta: metav1.ObjectMeta{ Name: "the-only-jaeger-instance-available", }, @@ -163,14 +163,14 @@ func TestSelectSingleJaegerPod(t *testing.T) { func TestCannotSelectFromMultipleJaegerPods(t *testing.T) { dep := dep(map[string]string{Annotation: "true"}, map[string]string{}) - jaegerPods := &v1alpha1.JaegerList{ - Items: []v1alpha1.Jaeger{ - v1alpha1.Jaeger{ + jaegerPods := &v1.JaegerList{ + Items: []v1.Jaeger{ + v1.Jaeger{ ObjectMeta: metav1.ObjectMeta{ Name: "the-first-jaeger-instance-available", }, }, - v1alpha1.Jaeger{ + v1.Jaeger{ ObjectMeta: metav1.ObjectMeta{ Name: "the-second-jaeger-instance-available", }, @@ -184,21 +184,21 @@ func TestCannotSelectFromMultipleJaegerPods(t *testing.T) { func TestNoAvailableJaegerPods(t *testing.T) { dep := dep(map[string]string{Annotation: "true"}, map[string]string{}) - jaeger := Select(dep, &v1alpha1.JaegerList{}) + jaeger := Select(dep, &v1.JaegerList{}) assert.Nil(t, jaeger) } func TestSelectBasedOnName(t *testing.T) { dep := dep(map[string]string{Annotation: "the-second-jaeger-instance-available"}, map[string]string{}) - jaegerPods := &v1alpha1.JaegerList{ - Items: []v1alpha1.Jaeger{ - v1alpha1.Jaeger{ + jaegerPods := &v1.JaegerList{ + Items: []v1.Jaeger{ + v1.Jaeger{ ObjectMeta: metav1.ObjectMeta{ Name: "the-first-jaeger-instance-available", }, }, - v1alpha1.Jaeger{ + v1.Jaeger{ ObjectMeta: metav1.ObjectMeta{ Name: "the-second-jaeger-instance-available", }, @@ -217,13 +217,13 @@ func dep(annotations map[string]string, labels map[string]string) *appsv1.Deploy Annotations: annotations, }, Spec: appsv1.DeploymentSpec{ - Template: v1.PodTemplateSpec{ + Template: corev1.PodTemplateSpec{ ObjectMeta: metav1.ObjectMeta{ Labels: labels, }, - Spec: v1.PodSpec{ - Containers: []v1.Container{ - v1.Container{}, + Spec: corev1.PodSpec{ + Containers: []corev1.Container{ + corev1.Container{}, }, }, }, diff --git a/pkg/route/query.go b/pkg/route/query.go index 158ab6f1f..1014d4b5d 100644 --- a/pkg/route/query.go +++ b/pkg/route/query.go @@ -1,39 +1,39 @@ package route import ( - "github.com/openshift/api/route/v1" + corev1 "github.com/openshift/api/route/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/service" ) // QueryRoute builds a route for jaegertracing/jaeger-query type QueryRoute struct { - jaeger *v1alpha1.Jaeger + jaeger *v1.Jaeger } // NewQueryRoute builds a new QueryRoute struct based on the given spec -func NewQueryRoute(jaeger *v1alpha1.Jaeger) *QueryRoute { +func NewQueryRoute(jaeger *v1.Jaeger) *QueryRoute { return &QueryRoute{jaeger: jaeger} } // Get returns an ingress specification for the current instance -func (r *QueryRoute) Get() *v1.Route { +func (r *QueryRoute) Get() *corev1.Route { if r.jaeger.Spec.Ingress.Enabled != nil && *r.jaeger.Spec.Ingress.Enabled == false { return nil } trueVar := true - var termination v1.TLSTerminationType - if r.jaeger.Spec.Ingress.Security == v1alpha1.IngressSecurityOAuthProxy { - termination = v1.TLSTerminationReencrypt + var termination corev1.TLSTerminationType + if r.jaeger.Spec.Ingress.Security == v1.IngressSecurityOAuthProxy { + termination = corev1.TLSTerminationReencrypt } else { - termination = v1.TLSTerminationEdge + termination = corev1.TLSTerminationEdge } - return &v1.Route{ + return &corev1.Route{ TypeMeta: metav1.TypeMeta{ Kind: "Route", APIVersion: "route.openshift.io/v1", @@ -59,12 +59,12 @@ func (r *QueryRoute) Get() *v1.Route { }, }, }, - Spec: v1.RouteSpec{ - To: v1.RouteTargetReference{ + Spec: corev1.RouteSpec{ + To: corev1.RouteTargetReference{ Kind: "Service", Name: service.GetNameForQueryService(r.jaeger), }, - TLS: &v1.TLSConfig{ + TLS: &corev1.TLSConfig{ Termination: termination, }, }, diff --git a/pkg/route/query_test.go b/pkg/route/query_test.go index cdecefd8f..21eadff47 100644 --- a/pkg/route/query_test.go +++ b/pkg/route/query_test.go @@ -4,15 +4,15 @@ import ( "fmt" "testing" - "github.com/openshift/api/route/v1" + corev1 "github.com/openshift/api/route/v1" "github.com/stretchr/testify/assert" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestQueryRoute(t *testing.T) { name := "TestQueryRoute" - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) route := NewQueryRoute(jaeger) dep := route.Get() @@ -23,7 +23,7 @@ func TestQueryRoute(t *testing.T) { func TestQueryRouteDisabled(t *testing.T) { enabled := false name := "TestQueryRouteDisabled" - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) jaeger.Spec.Ingress.Enabled = &enabled route := NewQueryRoute(jaeger) @@ -35,7 +35,7 @@ func TestQueryRouteDisabled(t *testing.T) { func TestQueryRouteEnabled(t *testing.T) { enabled := true name := "TestQueryRouteEnabled" - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) jaeger.Spec.Ingress.Enabled = &enabled route := NewQueryRoute(jaeger) @@ -45,19 +45,19 @@ func TestQueryRouteEnabled(t *testing.T) { } func TestQueryRouteTerminationTypeWithOAuthProxy(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestQueryRouteTerminationTypeWithOAuthProxy") - jaeger.Spec.Ingress.Security = v1alpha1.IngressSecurityOAuthProxy + jaeger := v1.NewJaeger("TestQueryRouteTerminationTypeWithOAuthProxy") + jaeger.Spec.Ingress.Security = v1.IngressSecurityOAuthProxy route := NewQueryRoute(jaeger) r := route.Get() - assert.Equal(t, v1.TLSTerminationReencrypt, r.Spec.TLS.Termination) + assert.Equal(t, corev1.TLSTerminationReencrypt, r.Spec.TLS.Termination) } func TestQueryRouteTerminationTypeWithoutOAuthProxy(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestQueryRouteTerminationTypeWithOAuthProxy") - jaeger.Spec.Ingress.Security = v1alpha1.IngressSecurityNone + jaeger := v1.NewJaeger("TestQueryRouteTerminationTypeWithOAuthProxy") + jaeger.Spec.Ingress.Security = v1.IngressSecurityNone route := NewQueryRoute(jaeger) r := route.Get() - assert.Equal(t, v1.TLSTerminationEdge, r.Spec.TLS.Termination) + assert.Equal(t, corev1.TLSTerminationEdge, r.Spec.TLS.Termination) } diff --git a/pkg/service/agent.go b/pkg/service/agent.go index 65f805a61..5a0faa345 100644 --- a/pkg/service/agent.go +++ b/pkg/service/agent.go @@ -3,17 +3,17 @@ package service import ( "fmt" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) // NewAgentService returns a new Kubernetes service for Jaeger Agent backed by the pods matching the selector -func NewAgentService(jaeger *v1alpha1.Jaeger, selector map[string]string) *v1.Service { +func NewAgentService(jaeger *v1.Jaeger, selector map[string]string) *corev1.Service { trueVar := true - return &v1.Service{ + return &corev1.Service{ TypeMeta: metav1.TypeMeta{ Kind: "Service", APIVersion: "v1", @@ -39,10 +39,10 @@ func NewAgentService(jaeger *v1alpha1.Jaeger, selector map[string]string) *v1.Se }, }, }, - Spec: v1.ServiceSpec{ + Spec: corev1.ServiceSpec{ Selector: selector, ClusterIP: "None", - Ports: []v1.ServicePort{ + Ports: []corev1.ServicePort{ { Name: "zk-compact-trft", Port: 5775, diff --git a/pkg/service/agent_test.go b/pkg/service/agent_test.go index 580ceeea5..c5be31f7f 100644 --- a/pkg/service/agent_test.go +++ b/pkg/service/agent_test.go @@ -6,14 +6,14 @@ import ( "github.com/stretchr/testify/assert" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestAgentServiceNameAndPorts(t *testing.T) { name := "TestAgentServiceNameAndPorts" selector := map[string]string{"app": "myapp", "jaeger": name, "jaeger-component": "agent"} - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) svc := NewAgentService(jaeger, selector) assert.Equal(t, svc.ObjectMeta.Name, fmt.Sprintf("%s-agent", name)) diff --git a/pkg/service/collector.go b/pkg/service/collector.go index e31a8439c..072c59429 100644 --- a/pkg/service/collector.go +++ b/pkg/service/collector.go @@ -3,17 +3,17 @@ package service import ( "fmt" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) // NewCollectorService returns a new Kubernetes service for Jaeger Collector backed by the pods matching the selector -func NewCollectorService(jaeger *v1alpha1.Jaeger, selector map[string]string) *v1.Service { +func NewCollectorService(jaeger *v1.Jaeger, selector map[string]string) *corev1.Service { trueVar := true - return &v1.Service{ + return &corev1.Service{ TypeMeta: metav1.TypeMeta{ Kind: "Service", APIVersion: "v1", @@ -39,10 +39,10 @@ func NewCollectorService(jaeger *v1alpha1.Jaeger, selector map[string]string) *v }, }, }, - Spec: v1.ServiceSpec{ + Spec: corev1.ServiceSpec{ Selector: selector, ClusterIP: "None", - Ports: []v1.ServicePort{ + Ports: []corev1.ServicePort{ { Name: "zipkin", Port: 9411, @@ -61,6 +61,6 @@ func NewCollectorService(jaeger *v1alpha1.Jaeger, selector map[string]string) *v } // GetNameForCollectorService returns the service name for the collector in this Jaeger instance -func GetNameForCollectorService(jaeger *v1alpha1.Jaeger) string { +func GetNameForCollectorService(jaeger *v1.Jaeger) string { return fmt.Sprintf("%s-collector", jaeger.Name) } diff --git a/pkg/service/collector_test.go b/pkg/service/collector_test.go index 0fa3ad864..54907fb7a 100644 --- a/pkg/service/collector_test.go +++ b/pkg/service/collector_test.go @@ -6,14 +6,14 @@ import ( "github.com/stretchr/testify/assert" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestCollectorServiceNameAndPorts(t *testing.T) { name := "TestCollectorServiceNameAndPorts" selector := map[string]string{"app": "myapp", "jaeger": name, "jaeger-component": "collector"} - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) svc := NewCollectorService(jaeger, selector) assert.Equal(t, svc.ObjectMeta.Name, fmt.Sprintf("%s-collector", name)) diff --git a/pkg/service/query.go b/pkg/service/query.go index 704b4ec8a..b921e74e1 100644 --- a/pkg/service/query.go +++ b/pkg/service/query.go @@ -3,23 +3,23 @@ package service import ( "fmt" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/intstr" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) // NewQueryService returns a new Kubernetes service for Jaeger Query backed by the pods matching the selector -func NewQueryService(jaeger *v1alpha1.Jaeger, selector map[string]string) *v1.Service { +func NewQueryService(jaeger *v1.Jaeger, selector map[string]string) *corev1.Service { trueVar := true annotations := map[string]string{} - if jaeger.Spec.Ingress.Security == v1alpha1.IngressSecurityOAuthProxy { + if jaeger.Spec.Ingress.Security == v1.IngressSecurityOAuthProxy { annotations["service.alpha.openshift.io/serving-cert-secret-name"] = GetTLSSecretNameForQueryService(jaeger) } - return &v1.Service{ + return &corev1.Service{ TypeMeta: metav1.TypeMeta{ Kind: "Service", APIVersion: "v1", @@ -46,10 +46,10 @@ func NewQueryService(jaeger *v1alpha1.Jaeger, selector map[string]string) *v1.Se }, }, }, - Spec: v1.ServiceSpec{ + Spec: corev1.ServiceSpec{ Selector: selector, ClusterIP: "None", - Ports: []v1.ServicePort{ + Ports: []corev1.ServicePort{ { Name: "query", Port: int32(GetPortForQueryService(jaeger)), @@ -61,25 +61,25 @@ func NewQueryService(jaeger *v1alpha1.Jaeger, selector map[string]string) *v1.Se } // GetNameForQueryService returns the query service name for this Jaeger instance -func GetNameForQueryService(jaeger *v1alpha1.Jaeger) string { +func GetNameForQueryService(jaeger *v1.Jaeger) string { return fmt.Sprintf("%s-query", jaeger.Name) } // GetTLSSecretNameForQueryService returns the auto-generated TLS secret name for the Query Service for the given Jaeger instance -func GetTLSSecretNameForQueryService(jaeger *v1alpha1.Jaeger) string { +func GetTLSSecretNameForQueryService(jaeger *v1.Jaeger) string { return fmt.Sprintf("%s-ui-oauth-proxy-tls", jaeger.Name) } // GetPortForQueryService returns the query service name for this Jaeger instance -func GetPortForQueryService(jaeger *v1alpha1.Jaeger) int { - if jaeger.Spec.Ingress.Security == v1alpha1.IngressSecurityOAuthProxy { +func GetPortForQueryService(jaeger *v1.Jaeger) int { + if jaeger.Spec.Ingress.Security == v1.IngressSecurityOAuthProxy { return 443 } return 16686 } -func getTargetPortForQueryService(jaeger *v1alpha1.Jaeger) int { - if jaeger.Spec.Ingress.Security == v1alpha1.IngressSecurityOAuthProxy { +func getTargetPortForQueryService(jaeger *v1.Jaeger) int { + if jaeger.Spec.Ingress.Security == v1.IngressSecurityOAuthProxy { return 8443 } return 16686 diff --git a/pkg/service/query_test.go b/pkg/service/query_test.go index f4324563d..56cc053a6 100644 --- a/pkg/service/query_test.go +++ b/pkg/service/query_test.go @@ -7,14 +7,14 @@ import ( "github.com/stretchr/testify/assert" "k8s.io/apimachinery/pkg/util/intstr" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestQueryServiceNameAndPorts(t *testing.T) { name := "TestQueryServiceNameAndPorts" selector := map[string]string{"app": "myapp", "jaeger": name, "jaeger-component": "query"} - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) svc := NewQueryService(jaeger, selector) assert.Equal(t, fmt.Sprintf("%s-query", name), svc.ObjectMeta.Name) @@ -27,8 +27,8 @@ func TestQueryServiceNameAndPortsWithOAuthProxy(t *testing.T) { name := "TestQueryServiceNameAndPortsWithOAuthProxy" selector := map[string]string{"app": "myapp", "jaeger": name, "jaeger-component": "query"} - jaeger := v1alpha1.NewJaeger(name) - jaeger.Spec.Ingress.Security = v1alpha1.IngressSecurityOAuthProxy + jaeger := v1.NewJaeger(name) + jaeger.Spec.Ingress.Security = v1.IngressSecurityOAuthProxy svc := NewQueryService(jaeger, selector) assert.Equal(t, fmt.Sprintf("%s-query", name), svc.ObjectMeta.Name) diff --git a/pkg/storage/cassandra_dependencies.go b/pkg/storage/cassandra_dependencies.go index 3e5badf0f..cc2baa0f9 100644 --- a/pkg/storage/cassandra_dependencies.go +++ b/pkg/storage/cassandra_dependencies.go @@ -5,13 +5,13 @@ import ( "github.com/spf13/viper" batchv1 "k8s.io/api/batch/v1" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) -func cassandraDeps(jaeger *v1alpha1.Jaeger) []batchv1.Job { +func cassandraDeps(jaeger *v1.Jaeger) []batchv1.Job { trueVar := true // TODO should be moved to normalize @@ -82,32 +82,26 @@ func cassandraDeps(jaeger *v1alpha1.Jaeger) []batchv1.Job { }, Spec: batchv1.JobSpec{ ActiveDeadlineSeconds: &deadline, - Template: v1.PodTemplateSpec{ + Template: corev1.PodTemplateSpec{ ObjectMeta: metav1.ObjectMeta{ Annotations: annotations, }, - Spec: v1.PodSpec{ - Containers: []v1.Container{ - v1.Container{ - Image: jaeger.Spec.Storage.CassandraCreateSchema.Image, - Name: fmt.Sprintf("%s-cassandra-schema", jaeger.Name), - Env: []v1.EnvVar{ - v1.EnvVar{ - Name: "CQLSH_HOST", - Value: host, - }, - v1.EnvVar{ - Name: "MODE", - Value: jaeger.Spec.Storage.CassandraCreateSchema.Mode, - }, - v1.EnvVar{ - Name: "DATACENTER", - Value: jaeger.Spec.Storage.CassandraCreateSchema.Datacenter, - }, - }, - }, - }, - RestartPolicy: v1.RestartPolicyOnFailure, + Spec: corev1.PodSpec{ + Containers: []corev1.Container{{ + Image: jaeger.Spec.Storage.CassandraCreateSchema.Image, + Name: fmt.Sprintf("%s-cassandra-schema", jaeger.Name), + Env: []corev1.EnvVar{{ + Name: "CQLSH_HOST", + Value: host, + }, { + Name: "MODE", + Value: jaeger.Spec.Storage.CassandraCreateSchema.Mode, + }, { + Name: "DATACENTER", + Value: jaeger.Spec.Storage.CassandraCreateSchema.Datacenter, + }}, + }}, + RestartPolicy: corev1.RestartPolicyOnFailure, }, }, }, diff --git a/pkg/storage/cassandra_dependencies_test.go b/pkg/storage/cassandra_dependencies_test.go index c7bd1ba22..cde8e9ec6 100644 --- a/pkg/storage/cassandra_dependencies_test.go +++ b/pkg/storage/cassandra_dependencies_test.go @@ -5,13 +5,13 @@ import ( "github.com/stretchr/testify/assert" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestCassandraCreateSchemaDisabled(t *testing.T) { falseVar := false - jaeger := v1alpha1.NewJaeger("TestCassandraCreateSchemaDisabled") + jaeger := v1.NewJaeger("TestCassandraCreateSchemaDisabled") jaeger.Spec.Storage.CassandraCreateSchema.Enabled = &falseVar assert.Len(t, cassandraDeps(jaeger), 0) @@ -20,14 +20,14 @@ func TestCassandraCreateSchemaDisabled(t *testing.T) { func TestCassandraCreateSchemaEnabled(t *testing.T) { trueVar := true - jaeger := v1alpha1.NewJaeger("TestCassandraCreateSchemaEnabled") + jaeger := v1.NewJaeger("TestCassandraCreateSchemaEnabled") jaeger.Spec.Storage.CassandraCreateSchema.Enabled = &trueVar assert.Len(t, cassandraDeps(jaeger), 1) } func TestCassandraCreateSchemaEnabledNil(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestCassandraCreateSchemaEnabledNil") + jaeger := v1.NewJaeger("TestCassandraCreateSchemaEnabledNil") assert.Nil(t, jaeger.Spec.Storage.CassandraCreateSchema.Enabled) assert.Len(t, cassandraDeps(jaeger), 1) diff --git a/pkg/storage/dependency.go b/pkg/storage/dependency.go index f9a18b32d..5e07b172a 100644 --- a/pkg/storage/dependency.go +++ b/pkg/storage/dependency.go @@ -5,11 +5,11 @@ import ( batchv1 "k8s.io/api/batch/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) // Dependencies return a list of Jobs that have to be finished before the other components are deployed -func Dependencies(jaeger *v1alpha1.Jaeger) []batchv1.Job { +func Dependencies(jaeger *v1.Jaeger) []batchv1.Job { if strings.EqualFold(jaeger.Spec.Storage.Type, "cassandra") { return cassandraDeps(jaeger) } diff --git a/pkg/storage/dependency_test.go b/pkg/storage/dependency_test.go index 0daf29706..047b48a22 100644 --- a/pkg/storage/dependency_test.go +++ b/pkg/storage/dependency_test.go @@ -5,16 +5,16 @@ import ( "github.com/stretchr/testify/assert" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestDefaultDependencies(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestCassandraDependencies") + jaeger := v1.NewJaeger("TestCassandraDependencies") assert.Len(t, Dependencies(jaeger), 0) } func TestCassandraDependencies(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestCassandraDependencies") + jaeger := v1.NewJaeger("TestCassandraDependencies") jaeger.Spec.Storage.Type = "CASSANDRA" // should be converted to lowercase assert.Len(t, Dependencies(jaeger), 1) } diff --git a/pkg/storage/elasticsearch.go b/pkg/storage/elasticsearch.go index dba6ecce0..d16083172 100644 --- a/pkg/storage/elasticsearch.go +++ b/pkg/storage/elasticsearch.go @@ -4,10 +4,10 @@ import ( "fmt" "strings" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" esv1alpha1 "github.com/jaegertracing/jaeger-operator/pkg/storage/elasticsearch/v1alpha1" ) @@ -23,7 +23,7 @@ const ( ) // ShouldDeployElasticsearch determines whether a new instance of Elasticsearch should be deployed -func ShouldDeployElasticsearch(s v1alpha1.JaegerStorageSpec) bool { +func ShouldDeployElasticsearch(s v1.JaegerStorageSpec) bool { if !strings.EqualFold(s.Type, "elasticsearch") { return false } @@ -33,15 +33,15 @@ func ShouldDeployElasticsearch(s v1alpha1.JaegerStorageSpec) bool { // ElasticsearchDeployment represents an ES deployment for Jaeger type ElasticsearchDeployment struct { - Jaeger *v1alpha1.Jaeger + Jaeger *v1.Jaeger } // InjectStorageConfiguration changes the given spec to include ES-related command line options -func (ed *ElasticsearchDeployment) InjectStorageConfiguration(p *v1.PodSpec) { - p.Volumes = append(p.Volumes, v1.Volume{ +func (ed *ElasticsearchDeployment) InjectStorageConfiguration(p *corev1.PodSpec) { + p.Volumes = append(p.Volumes, corev1.Volume{ Name: volumeName, - VolumeSource: v1.VolumeSource{ - Secret: &v1.SecretVolumeSource{ + VolumeSource: corev1.VolumeSource{ + Secret: &corev1.SecretVolumeSource{ SecretName: secretName(ed.Jaeger.Name, jaegerSecret.name), }, }, @@ -62,7 +62,7 @@ func (ed *ElasticsearchDeployment) InjectStorageConfiguration(p *v1.PodSpec) { p.Containers[0].Args = append(p.Containers[0].Args, fmt.Sprintf("--es.num-replicas=%d", calculateReplicaShards(ed.Jaeger.Spec.Storage.Elasticsearch.RedundancyPolicy, int(dataNodesCount(ed.Jaeger.Spec.Storage.Elasticsearch.NodeCount))))) } - p.Containers[0].VolumeMounts = append(p.Containers[0].VolumeMounts, v1.VolumeMount{ + p.Containers[0].VolumeMounts = append(p.Containers[0].VolumeMounts, corev1.VolumeMount{ Name: volumeName, ReadOnly: true, MountPath: volumeMountPath, @@ -71,11 +71,11 @@ func (ed *ElasticsearchDeployment) InjectStorageConfiguration(p *v1.PodSpec) { } // InjectIndexCleanerConfiguration changes the given spec to include the options for the index cleaner -func (ed *ElasticsearchDeployment) InjectIndexCleanerConfiguration(p *v1.PodSpec) { - p.Volumes = append(p.Volumes, v1.Volume{ +func (ed *ElasticsearchDeployment) InjectIndexCleanerConfiguration(p *corev1.PodSpec) { + p.Volumes = append(p.Volumes, corev1.Volume{ Name: volumeName, - VolumeSource: v1.VolumeSource{ - Secret: &v1.SecretVolumeSource{ + VolumeSource: corev1.VolumeSource{ + Secret: &corev1.SecretVolumeSource{ SecretName: secretName(ed.Jaeger.Name, curatorSecret.name), }, }, @@ -85,12 +85,12 @@ func (ed *ElasticsearchDeployment) InjectIndexCleanerConfiguration(p *v1.PodSpec // the size of arguments array should be always 2 p.Containers[0].Args[1] = elasticsearchURL p.Containers[0].Env = append(p.Containers[0].Env, - v1.EnvVar{Name: "ES_TLS", Value: "true"}, - v1.EnvVar{Name: "ES_TLS_CA", Value: caPath}, - v1.EnvVar{Name: "ES_TLS_KEY", Value: keyPath}, - v1.EnvVar{Name: "ES_TLS_CERT", Value: certPath}, + corev1.EnvVar{Name: "ES_TLS", Value: "true"}, + corev1.EnvVar{Name: "ES_TLS_CA", Value: caPath}, + corev1.EnvVar{Name: "ES_TLS_KEY", Value: keyPath}, + corev1.EnvVar{Name: "ES_TLS_CERT", Value: certPath}, ) - p.Containers[0].VolumeMounts = append(p.Containers[0].VolumeMounts, v1.VolumeMount{ + p.Containers[0].VolumeMounts = append(p.Containers[0].VolumeMounts, corev1.VolumeMount{ Name: volumeName, ReadOnly: true, MountPath: volumeMountPath, @@ -127,7 +127,7 @@ func (ed *ElasticsearchDeployment) Elasticsearch() *esv1alpha1.Elasticsearch { } } -func getNodes(es v1alpha1.ElasticsearchSpec) []esv1alpha1.ElasticsearchNode { +func getNodes(es v1.ElasticsearchSpec) []esv1alpha1.ElasticsearchNode { if es.NodeCount <= 3 { return []esv1alpha1.ElasticsearchNode{ { diff --git a/pkg/storage/elasticsearch_role.go b/pkg/storage/elasticsearch_role.go index 9932e4d84..c489ef270 100644 --- a/pkg/storage/elasticsearch_role.go +++ b/pkg/storage/elasticsearch_role.go @@ -6,11 +6,11 @@ import ( rbacv1 "k8s.io/api/rbac/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) // ESRole returns the role to be created for Elasticsearch -func ESRole(jaeger *v1alpha1.Jaeger) rbacv1.Role { +func ESRole(jaeger *v1.Jaeger) rbacv1.Role { return rbacv1.Role{ ObjectMeta: metav1.ObjectMeta{ Annotations: map[string]string{rbacv1.AutoUpdateAnnotationKey: "true"}, @@ -41,7 +41,7 @@ func ESRole(jaeger *v1alpha1.Jaeger) rbacv1.Role { } // ESRoleBinding returns the Elasticsearch role bindings to be created for the given subjects -func ESRoleBinding(jaeger *v1alpha1.Jaeger, sas ...string) rbacv1.RoleBinding { +func ESRoleBinding(jaeger *v1.Jaeger, sas ...string) rbacv1.RoleBinding { rb := rbacv1.RoleBinding{ ObjectMeta: metav1.ObjectMeta{ Name: fmt.Sprintf("%s-elasticsearch", jaeger.Name), diff --git a/pkg/storage/elasticsearch_role_test.go b/pkg/storage/elasticsearch_role_test.go index 25821665f..f93b54608 100644 --- a/pkg/storage/elasticsearch_role_test.go +++ b/pkg/storage/elasticsearch_role_test.go @@ -6,11 +6,11 @@ import ( "github.com/stretchr/testify/assert" rbacv1 "k8s.io/api/rbac/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestGetESRoles_NoDeployment(t *testing.T) { - j := v1alpha1.NewJaeger("foo") + j := v1.NewJaeger("foo") r := ESRole(j) assert.Equal(t, []rbacv1.PolicyRule{ { @@ -25,7 +25,7 @@ func TestGetESRoles_NoDeployment(t *testing.T) { } func TestGetESRoles_ServiceAccount(t *testing.T) { - j := v1alpha1.NewJaeger("foo") + j := v1.NewJaeger("foo") j.Namespace = "myproject" r := ESRole(j) diff --git a/pkg/storage/elasticsearch_secrets.go b/pkg/storage/elasticsearch_secrets.go index a3b8bc651..d4bfd2eaa 100644 --- a/pkg/storage/elasticsearch_secrets.go +++ b/pkg/storage/elasticsearch_secrets.go @@ -10,10 +10,10 @@ import ( "github.com/operator-framework/operator-sdk/pkg/k8sutil" log "github.com/sirupsen/logrus" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) const ( @@ -60,8 +60,8 @@ func secretName(jaeger, secret string) string { } // ESSecrets assembles a set of secrets related to Elasticsearch -func ESSecrets(jaeger *v1alpha1.Jaeger) []v1.Secret { - return []v1.Secret{ +func ESSecrets(jaeger *v1.Jaeger) []corev1.Secret { + return []corev1.Secret{ // master and ES secrets use hardcoded name - e.g. do not use instance name in it // the other problem for us is that sg_config.yml defines a role which depends on namespace // we could make the "resource" configurable once ES image and es-operator-are refactored @@ -98,8 +98,8 @@ func createESCerts(script string) error { return nil } -func createSecret(jaeger *v1alpha1.Jaeger, secretName string, data map[string][]byte) v1.Secret { - return v1.Secret{ +func createSecret(jaeger *v1.Jaeger, secretName string, data map[string][]byte) corev1.Secret { + return corev1.Secret{ ObjectMeta: metav1.ObjectMeta{ Name: secretName, Namespace: jaeger.Namespace, @@ -113,12 +113,12 @@ func createSecret(jaeger *v1alpha1.Jaeger, secretName string, data map[string][] }, OwnerReferences: []metav1.OwnerReference{asOwner(jaeger)}, }, - Type: v1.SecretTypeOpaque, + Type: corev1.SecretTypeOpaque, Data: data, } } -func asOwner(jaeger *v1alpha1.Jaeger) metav1.OwnerReference { +func asOwner(jaeger *v1.Jaeger) metav1.OwnerReference { b := true return metav1.OwnerReference{ APIVersion: jaeger.APIVersion, diff --git a/pkg/storage/elasticsearch_secrets_test.go b/pkg/storage/elasticsearch_secrets_test.go index 8a664df47..3508f362e 100644 --- a/pkg/storage/elasticsearch_secrets_test.go +++ b/pkg/storage/elasticsearch_secrets_test.go @@ -7,9 +7,9 @@ import ( "testing" "github.com/stretchr/testify/assert" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestCreateCerts_ErrNoNamespace(t *testing.T) { @@ -26,7 +26,7 @@ func TestCreateCerts_ErrNoScript(t *testing.T) { func TestCreateESSecrets(t *testing.T) { defer os.RemoveAll(workingDir) - j := v1alpha1.NewJaeger("foo") + j := v1.NewJaeger("foo") os.Setenv("WATCH_NAMESPACE", "invalid.&*)(") defer os.Unsetenv("WATCH_NAMESPACE") fmt.Println(os.Getwd()) @@ -50,7 +50,7 @@ func TestCreateESSecrets(t *testing.T) { func TestCreteSecret(t *testing.T) { defer os.RemoveAll(workingDir) - j := v1alpha1.NewJaeger("foo") + j := v1.NewJaeger("foo") j.Namespace = "myproject" s := createSecret(j, "bar", map[string][]byte{"foo": {}}) assert.Equal(t, "bar", s.ObjectMeta.Name) @@ -58,7 +58,7 @@ func TestCreteSecret(t *testing.T) { assert.Equal(t, j.Name, s.ObjectMeta.OwnerReferences[0].Name) assert.Equal(t, j.Name, s.ObjectMeta.OwnerReferences[0].Name) assert.Equal(t, map[string][]byte{"foo": {}}, s.Data) - assert.Equal(t, v1.SecretTypeOpaque, s.Type) + assert.Equal(t, corev1.SecretTypeOpaque, s.Type) } func TestGetWorkingFileDirContent(t *testing.T) { diff --git a/pkg/storage/elasticsearch_test.go b/pkg/storage/elasticsearch_test.go index 9e6186551..bb326134f 100644 --- a/pkg/storage/elasticsearch_test.go +++ b/pkg/storage/elasticsearch_test.go @@ -4,22 +4,22 @@ import ( "testing" "github.com/stretchr/testify/assert" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" esv1alpha1 "github.com/jaegertracing/jaeger-operator/pkg/storage/elasticsearch/v1alpha1" ) func TestShouldDeployElasticsearch(t *testing.T) { tests := []struct { - j v1alpha1.JaegerStorageSpec + j v1.JaegerStorageSpec expected bool }{ - {j: v1alpha1.JaegerStorageSpec{}}, - {j: v1alpha1.JaegerStorageSpec{Type: "cassandra"}}, - {j: v1alpha1.JaegerStorageSpec{Type: "elasticsearch", Options: v1alpha1.NewOptions(map[string]interface{}{"es.server-urls": "foo"})}}, - {j: v1alpha1.JaegerStorageSpec{Type: "elasticsearch"}, expected: true}, + {j: v1.JaegerStorageSpec{}}, + {j: v1.JaegerStorageSpec{Type: "cassandra"}}, + {j: v1.JaegerStorageSpec{Type: "elasticsearch", Options: v1.NewOptions(map[string]interface{}{"es.server-urls": "foo"})}}, + {j: v1.JaegerStorageSpec{Type: "elasticsearch"}, expected: true}, } for _, test := range tests { assert.Equal(t, test.expected, ShouldDeployElasticsearch(test.j)) @@ -28,11 +28,11 @@ func TestShouldDeployElasticsearch(t *testing.T) { func TestCreateElasticsearchCR(t *testing.T) { tests := []struct { - jEsSpec v1alpha1.ElasticsearchSpec + jEsSpec v1.ElasticsearchSpec esSpec esv1alpha1.ElasticsearchSpec }{ { - jEsSpec: v1alpha1.ElasticsearchSpec{ + jEsSpec: v1.ElasticsearchSpec{ NodeCount: 2, RedundancyPolicy: esv1alpha1.FullRedundancy, Storage: esv1alpha1.ElasticsearchStorageSpec{ @@ -53,7 +53,7 @@ func TestCreateElasticsearchCR(t *testing.T) { }, }, { - jEsSpec: v1alpha1.ElasticsearchSpec{ + jEsSpec: v1.ElasticsearchSpec{ NodeCount: 5, RedundancyPolicy: esv1alpha1.FullRedundancy, Storage: esv1alpha1.ElasticsearchStorageSpec{ @@ -80,7 +80,7 @@ func TestCreateElasticsearchCR(t *testing.T) { }, } for _, test := range tests { - j := v1alpha1.NewJaeger("foo") + j := v1.NewJaeger("foo") j.Namespace = "myproject" j.Spec.Storage.Elasticsearch = test.jEsSpec es := &ElasticsearchDeployment{Jaeger: j} @@ -95,18 +95,18 @@ func TestCreateElasticsearchCR(t *testing.T) { func TestInject(t *testing.T) { tests := []struct { - pod *v1.PodSpec - expected *v1.PodSpec - es v1alpha1.ElasticsearchSpec + pod *corev1.PodSpec + expected *corev1.PodSpec + es v1.ElasticsearchSpec }{ - {pod: &v1.PodSpec{ - Containers: []v1.Container{{ + {pod: &corev1.PodSpec{ + Containers: []corev1.Container{{ Args: []string{"foo"}, - VolumeMounts: []v1.VolumeMount{{Name: "lol"}}, + VolumeMounts: []corev1.VolumeMount{{Name: "lol"}}, }}, }, - expected: &v1.PodSpec{ - Containers: []v1.Container{{ + expected: &corev1.PodSpec{ + Containers: []corev1.Container{{ Args: []string{ "foo", "--es.server-urls=" + elasticsearchURL, @@ -115,23 +115,23 @@ func TestInject(t *testing.T) { "--es.num-shards=0", "--es.num-replicas=1", }, - VolumeMounts: []v1.VolumeMount{ + VolumeMounts: []corev1.VolumeMount{ {Name: "lol"}, {Name: volumeName, ReadOnly: true, MountPath: volumeMountPath}, }, }}, - Volumes: []v1.Volume{{Name: "certs", VolumeSource: v1.VolumeSource{ - Secret: &v1.SecretVolumeSource{ + Volumes: []corev1.Volume{{Name: "certs", VolumeSource: corev1.VolumeSource{ + Secret: &corev1.SecretVolumeSource{ SecretName: "hoo-jaeger-elasticsearch"}}}, }}, }, - {pod: &v1.PodSpec{ - Containers: []v1.Container{{ + {pod: &corev1.PodSpec{ + Containers: []corev1.Container{{ Args: []string{"--es.num-shards=15"}, }}, }, - expected: &v1.PodSpec{ - Containers: []v1.Container{{ + expected: &corev1.PodSpec{ + Containers: []corev1.Container{{ Args: []string{ "--es.num-shards=15", "--es.server-urls=" + elasticsearchURL, @@ -139,20 +139,20 @@ func TestInject(t *testing.T) { "--es.tls.ca=" + caPath, "--es.num-replicas=1", }, - VolumeMounts: []v1.VolumeMount{ + VolumeMounts: []corev1.VolumeMount{ {Name: volumeName, ReadOnly: true, MountPath: volumeMountPath}, }, }}, - Volumes: []v1.Volume{{Name: "certs", VolumeSource: v1.VolumeSource{ - Secret: &v1.SecretVolumeSource{ + Volumes: []corev1.Volume{{Name: "certs", VolumeSource: corev1.VolumeSource{ + Secret: &corev1.SecretVolumeSource{ SecretName: "hoo-jaeger-elasticsearch"}}}, }}, }, { - pod: &v1.PodSpec{Containers: []v1.Container{{}}}, - es: v1alpha1.ElasticsearchSpec{NodeCount: 15, RedundancyPolicy: esv1alpha1.FullRedundancy}, - expected: &v1.PodSpec{ - Containers: []v1.Container{{ + pod: &corev1.PodSpec{Containers: []corev1.Container{{}}}, + es: v1.ElasticsearchSpec{NodeCount: 15, RedundancyPolicy: esv1alpha1.FullRedundancy}, + expected: &corev1.PodSpec{ + Containers: []corev1.Container{{ Args: []string{ "--es.server-urls=" + elasticsearchURL, "--es.token-file=" + k8sTokenFile, @@ -160,19 +160,19 @@ func TestInject(t *testing.T) { "--es.num-shards=12", "--es.num-replicas=11", }, - VolumeMounts: []v1.VolumeMount{ + VolumeMounts: []corev1.VolumeMount{ {Name: volumeName, ReadOnly: true, MountPath: volumeMountPath}, }, }}, - Volumes: []v1.Volume{{Name: "certs", VolumeSource: v1.VolumeSource{ - Secret: &v1.SecretVolumeSource{ + Volumes: []corev1.Volume{{Name: "certs", VolumeSource: corev1.VolumeSource{ + Secret: &corev1.SecretVolumeSource{ SecretName: "hoo-jaeger-elasticsearch"}}}, }}, }, } for _, test := range tests { - es := &ElasticsearchDeployment{Jaeger: v1alpha1.NewJaeger("hoo")} + es := &ElasticsearchDeployment{Jaeger: v1.NewJaeger("hoo")} es.Jaeger.Spec.Storage.Elasticsearch = test.es es.InjectStorageConfiguration(test.pod) assert.Equal(t, test.expected, test.pod) diff --git a/pkg/strategy/all-in-one.go b/pkg/strategy/all-in-one.go index 70c3b5d87..2ae188333 100644 --- a/pkg/strategy/all-in-one.go +++ b/pkg/strategy/all-in-one.go @@ -7,7 +7,7 @@ import ( appsv1 "k8s.io/api/apps/v1" "github.com/jaegertracing/jaeger-operator/pkg/account" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/config/sampling" "github.com/jaegertracing/jaeger-operator/pkg/config/ui" "github.com/jaegertracing/jaeger-operator/pkg/cronjob" @@ -18,7 +18,7 @@ import ( "github.com/jaegertracing/jaeger-operator/pkg/storage" ) -func newAllInOneStrategy(jaeger *v1alpha1.Jaeger) S { +func newAllInOneStrategy(jaeger *v1.Jaeger) S { c := S{typ: AllInOne} jaeger.Logger().Debug("Creating all-in-one deployment") @@ -53,7 +53,7 @@ func newAllInOneStrategy(jaeger *v1alpha1.Jaeger) S { } // add the routes/ingresses - if viper.GetString("platform") == v1alpha1.FlagPlatformOpenShift { + if viper.GetString("platform") == v1.FlagPlatformOpenShift { if q := route.NewQueryRoute(jaeger).Get(); nil != q { c.routes = append(c.routes, *q) } diff --git a/pkg/strategy/all-in-one_test.go b/pkg/strategy/all-in-one_test.go index 916f80e16..0717fa55e 100644 --- a/pkg/strategy/all-in-one_test.go +++ b/pkg/strategy/all-in-one_test.go @@ -7,7 +7,7 @@ import ( "github.com/spf13/viper" "github.com/stretchr/testify/assert" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/storage" ) @@ -18,7 +18,7 @@ func init() { func TestCreateAllInOneDeployment(t *testing.T) { name := "TestCreateAllInOneDeployment" - c := newAllInOneStrategy(v1alpha1.NewJaeger(name)) + c := newAllInOneStrategy(v1.NewJaeger(name)) assertDeploymentsAndServicesForAllInOne(t, name, c, false, false, false) } @@ -27,7 +27,7 @@ func TestCreateAllInOneDeploymentOnOpenShift(t *testing.T) { defer viper.Reset() name := "TestCreateAllInOneDeploymentOnOpenShift" - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) normalize(jaeger) c := newAllInOneStrategy(jaeger) @@ -37,7 +37,7 @@ func TestCreateAllInOneDeploymentOnOpenShift(t *testing.T) { func TestCreateAllInOneDeploymentWithDaemonSetAgent(t *testing.T) { name := "TestCreateAllInOneDeploymentWithDaemonSetAgent" - j := v1alpha1.NewJaeger(name) + j := v1.NewJaeger(name) j.Spec.Agent.Strategy = "DaemonSet" c := newAllInOneStrategy(j) @@ -47,8 +47,8 @@ func TestCreateAllInOneDeploymentWithDaemonSetAgent(t *testing.T) { func TestCreateAllInOneDeploymentWithUIConfigMap(t *testing.T) { name := "TestCreateAllInOneDeploymentWithUIConfigMap" - j := v1alpha1.NewJaeger(name) - j.Spec.UI.Options = v1alpha1.NewFreeForm(map[string]interface{}{ + j := v1.NewJaeger(name) + j.Spec.UI.Options = v1.NewFreeForm(map[string]interface{}{ "tracking": map[string]interface{}{ "gaID": "UA-000000-2", }, @@ -60,7 +60,7 @@ func TestCreateAllInOneDeploymentWithUIConfigMap(t *testing.T) { func TestDelegateAllInOneDependencies(t *testing.T) { // for now, we just have storage dependencies - j := v1alpha1.NewJaeger("TestDelegateAllInOneDependencies") + j := v1.NewJaeger("TestDelegateAllInOneDependencies") c := newAllInOneStrategy(j) assert.Equal(t, c.Dependencies(), storage.Dependencies(j)) } @@ -101,7 +101,7 @@ func assertDeploymentsAndServicesForAllInOne(t *testing.T, name string, s S, has // the ingress rule, if we are not on openshift ingresses := map[string]bool{} routes := map[string]bool{} - if viper.GetString("platform") == v1alpha1.FlagPlatformOpenShift { + if viper.GetString("platform") == v1.FlagPlatformOpenShift { routes[fmt.Sprintf("%s", name)] = false } else { ingresses[fmt.Sprintf("%s-query", name)] = false @@ -120,31 +120,31 @@ func assertDeploymentsAndServicesForAllInOne(t *testing.T, name string, s S, has } func TestSparkDependenciesAllInOne(t *testing.T) { - testSparkDependencies(t, func(jaeger *v1alpha1.Jaeger) S { + testSparkDependencies(t, func(jaeger *v1.Jaeger) S { return newAllInOneStrategy(jaeger) }) } -func testSparkDependencies(t *testing.T, fce func(jaeger *v1alpha1.Jaeger) S) { +func testSparkDependencies(t *testing.T, fce func(jaeger *v1.Jaeger) S) { trueVar := true tests := []struct { - jaeger *v1alpha1.Jaeger + jaeger *v1.Jaeger sparkCronJobEnabled bool }{ - {jaeger: &v1alpha1.Jaeger{Spec: v1alpha1.JaegerSpec{ - Storage: v1alpha1.JaegerStorageSpec{Type: "elasticsearch", - SparkDependencies: v1alpha1.JaegerDependenciesSpec{Enabled: &trueVar}}, + {jaeger: &v1.Jaeger{Spec: v1.JaegerSpec{ + Storage: v1.JaegerStorageSpec{Type: "elasticsearch", + SparkDependencies: v1.JaegerDependenciesSpec{Enabled: &trueVar}}, }}, sparkCronJobEnabled: true}, - {jaeger: &v1alpha1.Jaeger{Spec: v1alpha1.JaegerSpec{ - Storage: v1alpha1.JaegerStorageSpec{Type: "cassandra", - SparkDependencies: v1alpha1.JaegerDependenciesSpec{Enabled: &trueVar}}, + {jaeger: &v1.Jaeger{Spec: v1.JaegerSpec{ + Storage: v1.JaegerStorageSpec{Type: "cassandra", + SparkDependencies: v1.JaegerDependenciesSpec{Enabled: &trueVar}}, }}, sparkCronJobEnabled: true}, - {jaeger: &v1alpha1.Jaeger{Spec: v1alpha1.JaegerSpec{ - Storage: v1alpha1.JaegerStorageSpec{Type: "kafka", - SparkDependencies: v1alpha1.JaegerDependenciesSpec{Enabled: &trueVar}}, + {jaeger: &v1.Jaeger{Spec: v1.JaegerSpec{ + Storage: v1.JaegerStorageSpec{Type: "kafka", + SparkDependencies: v1.JaegerDependenciesSpec{Enabled: &trueVar}}, }}, sparkCronJobEnabled: false}, - {jaeger: &v1alpha1.Jaeger{Spec: v1alpha1.JaegerSpec{ - Storage: v1alpha1.JaegerStorageSpec{Type: "elasticsearch"}, + {jaeger: &v1.Jaeger{Spec: v1.JaegerSpec{ + Storage: v1.JaegerStorageSpec{Type: "elasticsearch"}, }}, sparkCronJobEnabled: false}, } for _, test := range tests { @@ -159,31 +159,31 @@ func testSparkDependencies(t *testing.T, fce func(jaeger *v1alpha1.Jaeger) S) { } func TestEsIndexCleanerAllInOne(t *testing.T) { - testEsIndexCleaner(t, func(jaeger *v1alpha1.Jaeger) S { + testEsIndexCleaner(t, func(jaeger *v1.Jaeger) S { return newAllInOneStrategy(jaeger) }) } -func testEsIndexCleaner(t *testing.T, fce func(jaeger *v1alpha1.Jaeger) S) { +func testEsIndexCleaner(t *testing.T, fce func(jaeger *v1.Jaeger) S) { trueVar := true tests := []struct { - jaeger *v1alpha1.Jaeger + jaeger *v1.Jaeger sparkCronJobEnabled bool }{ - {jaeger: &v1alpha1.Jaeger{Spec: v1alpha1.JaegerSpec{ - Storage: v1alpha1.JaegerStorageSpec{Type: "elasticsearch", - EsIndexCleaner: v1alpha1.JaegerEsIndexCleanerSpec{Enabled: &trueVar}}, + {jaeger: &v1.Jaeger{Spec: v1.JaegerSpec{ + Storage: v1.JaegerStorageSpec{Type: "elasticsearch", + EsIndexCleaner: v1.JaegerEsIndexCleanerSpec{Enabled: &trueVar}}, }}, sparkCronJobEnabled: true}, - {jaeger: &v1alpha1.Jaeger{Spec: v1alpha1.JaegerSpec{ - Storage: v1alpha1.JaegerStorageSpec{Type: "cassandra", - EsIndexCleaner: v1alpha1.JaegerEsIndexCleanerSpec{Enabled: &trueVar}}, + {jaeger: &v1.Jaeger{Spec: v1.JaegerSpec{ + Storage: v1.JaegerStorageSpec{Type: "cassandra", + EsIndexCleaner: v1.JaegerEsIndexCleanerSpec{Enabled: &trueVar}}, }}, sparkCronJobEnabled: false}, - {jaeger: &v1alpha1.Jaeger{Spec: v1alpha1.JaegerSpec{ - Storage: v1alpha1.JaegerStorageSpec{Type: "kafka", - EsIndexCleaner: v1alpha1.JaegerEsIndexCleanerSpec{Enabled: &trueVar}}, + {jaeger: &v1.Jaeger{Spec: v1.JaegerSpec{ + Storage: v1.JaegerStorageSpec{Type: "kafka", + EsIndexCleaner: v1.JaegerEsIndexCleanerSpec{Enabled: &trueVar}}, }}, sparkCronJobEnabled: false}, - {jaeger: &v1alpha1.Jaeger{Spec: v1alpha1.JaegerSpec{ - Storage: v1alpha1.JaegerStorageSpec{Type: "elasticsearch"}, + {jaeger: &v1.Jaeger{Spec: v1.JaegerSpec{ + Storage: v1.JaegerStorageSpec{Type: "elasticsearch"}, }}, sparkCronJobEnabled: false}, } for _, test := range tests { diff --git a/pkg/strategy/controller.go b/pkg/strategy/controller.go index 629be4bed..12e9bcb1a 100644 --- a/pkg/strategy/controller.go +++ b/pkg/strategy/controller.go @@ -8,13 +8,13 @@ import ( log "github.com/sirupsen/logrus" "github.com/spf13/viper" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/cronjob" "github.com/jaegertracing/jaeger-operator/pkg/storage" ) // For returns the appropriate Strategy for the given Jaeger instance -func For(ctx context.Context, jaeger *v1alpha1.Jaeger) S { +func For(ctx context.Context, jaeger *v1.Jaeger) S { if strings.EqualFold(jaeger.Spec.Strategy, "all-in-one") { jaeger.Logger().Warn("Strategy 'all-in-one' is no longer supported, please use 'allInOne'") jaeger.Spec.Strategy = "allInOne" @@ -36,7 +36,7 @@ func For(ctx context.Context, jaeger *v1alpha1.Jaeger) S { // normalize changes the incoming Jaeger object so that the defaults are applied when // needed and incompatible options are cleaned -func normalize(jaeger *v1alpha1.Jaeger) { +func normalize(jaeger *v1.Jaeger) { // we need a name! if jaeger.Name == "" { jaeger.Logger().Info("This Jaeger instance was created without a name. Applying a default name.") @@ -70,13 +70,13 @@ func normalize(jaeger *v1alpha1.Jaeger) { } // we always set the value to None, except when we are on OpenShift *and* the user has not explicitly set to 'none' - if viper.GetString("platform") == v1alpha1.FlagPlatformOpenShift && jaeger.Spec.Ingress.Security != v1alpha1.IngressSecurityNoneExplicit { - jaeger.Spec.Ingress.Security = v1alpha1.IngressSecurityOAuthProxy + if viper.GetString("platform") == v1.FlagPlatformOpenShift && jaeger.Spec.Ingress.Security != v1.IngressSecurityNoneExplicit { + jaeger.Spec.Ingress.Security = v1.IngressSecurityOAuthProxy } else { // cases: // - omitted on Kubernetes // - 'none' on any platform - jaeger.Spec.Ingress.Security = v1alpha1.IngressSecurityNone + jaeger.Spec.Ingress.Security = v1.IngressSecurityNone } normalizeSparkDependencies(&jaeger.Spec.Storage.SparkDependencies, jaeger.Spec.Storage.Type) @@ -84,7 +84,7 @@ func normalize(jaeger *v1alpha1.Jaeger) { normalizeElasticsearch(&jaeger.Spec.Storage.Elasticsearch) } -func normalizeSparkDependencies(spec *v1alpha1.JaegerDependenciesSpec, storage string) { +func normalizeSparkDependencies(spec *v1.JaegerDependenciesSpec, storage string) { // auto enable only for supported storages if cronjob.SupportedStorage(storage) && spec.Enabled == nil { trueVar := true @@ -98,7 +98,7 @@ func normalizeSparkDependencies(spec *v1alpha1.JaegerDependenciesSpec, storage s } } -func normalizeIndexCleaner(spec *v1alpha1.JaegerEsIndexCleanerSpec, storage string) { +func normalizeIndexCleaner(spec *v1.JaegerEsIndexCleanerSpec, storage string) { // auto enable only for supported storages if storage == "elasticsearch" && spec.Enabled == nil { trueVar := true @@ -115,7 +115,7 @@ func normalizeIndexCleaner(spec *v1alpha1.JaegerEsIndexCleanerSpec, storage stri } } -func normalizeElasticsearch(spec *v1alpha1.ElasticsearchSpec) { +func normalizeElasticsearch(spec *v1.ElasticsearchSpec) { if spec.NodeCount == 0 { spec.NodeCount = 1 } diff --git a/pkg/strategy/controller_test.go b/pkg/strategy/controller_test.go index 9f6a6d269..ad2f65abd 100644 --- a/pkg/strategy/controller_test.go +++ b/pkg/strategy/controller_test.go @@ -10,18 +10,18 @@ import ( appsv1 "k8s.io/api/apps/v1" "k8s.io/apimachinery/pkg/runtime" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestNewControllerForAllInOneAsDefault(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestNewControllerForAllInOneAsDefault") + jaeger := v1.NewJaeger("TestNewControllerForAllInOneAsDefault") ctrl := For(context.TODO(), jaeger) assert.Equal(t, ctrl.Type(), AllInOne) } func TestNewControllerForAllInOneAsExplicitValue(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestNewControllerForAllInOneAsExplicitValue") + jaeger := v1.NewJaeger("TestNewControllerForAllInOneAsExplicitValue") jaeger.Spec.Strategy = "ALL-IN-ONE" // same as 'all-in-one' ctrl := For(context.TODO(), jaeger) @@ -29,7 +29,7 @@ func TestNewControllerForAllInOneAsExplicitValue(t *testing.T) { } func TestNewControllerForProduction(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestNewControllerForProduction") + jaeger := v1.NewJaeger("TestNewControllerForProduction") jaeger.Spec.Strategy = "production" jaeger.Spec.Storage.Type = "elasticsearch" @@ -38,17 +38,17 @@ func TestNewControllerForProduction(t *testing.T) { } func TestUnknownStorage(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestNewControllerForProduction") + jaeger := v1.NewJaeger("TestNewControllerForProduction") jaeger.Spec.Storage.Type = "unknown" normalize(jaeger) assert.Equal(t, "memory", jaeger.Spec.Storage.Type) } func TestElasticsearchAsStorageOptions(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestElasticsearchAsStorageOptions") + jaeger := v1.NewJaeger("TestElasticsearchAsStorageOptions") jaeger.Spec.Strategy = "production" jaeger.Spec.Storage.Type = "elasticsearch" - jaeger.Spec.Storage.Options = v1alpha1.NewOptions(map[string]interface{}{ + jaeger.Spec.Storage.Options = v1.NewOptions(map[string]interface{}{ "es.server-urls": "http://elasticsearch-example-es-cluster:9200", }) @@ -68,16 +68,16 @@ func TestElasticsearchAsStorageOptions(t *testing.T) { } func TestDefaultName(t *testing.T) { - jaeger := &v1alpha1.Jaeger{} + jaeger := &v1.Jaeger{} normalize(jaeger) assert.NotEmpty(t, jaeger.Name) } func TestIncompatibleStorageForProduction(t *testing.T) { - jaeger := &v1alpha1.Jaeger{ - Spec: v1alpha1.JaegerSpec{ + jaeger := &v1.Jaeger{ + Spec: v1.JaegerSpec{ Strategy: "production", - Storage: v1alpha1.JaegerStorageSpec{ + Storage: v1.JaegerStorageSpec{ Type: "memory", }, }, @@ -87,10 +87,10 @@ func TestIncompatibleStorageForProduction(t *testing.T) { } func TestIncompatibleStorageForStreaming(t *testing.T) { - jaeger := &v1alpha1.Jaeger{ - Spec: v1alpha1.JaegerSpec{ + jaeger := &v1.Jaeger{ + Spec: v1.JaegerSpec{ Strategy: "streaming", - Storage: v1alpha1.JaegerStorageSpec{ + Storage: v1.JaegerStorageSpec{ Type: "memory", }, }, @@ -100,8 +100,8 @@ func TestIncompatibleStorageForStreaming(t *testing.T) { } func TestDeprecatedAllInOneStrategy(t *testing.T) { - jaeger := &v1alpha1.Jaeger{ - Spec: v1alpha1.JaegerSpec{ + jaeger := &v1.Jaeger{ + Spec: v1.JaegerSpec{ Strategy: "all-in-one", }, } @@ -110,10 +110,10 @@ func TestDeprecatedAllInOneStrategy(t *testing.T) { } func TestStorageMemoryOnlyUsedWithAllInOneStrategy(t *testing.T) { - jaeger := &v1alpha1.Jaeger{ - Spec: v1alpha1.JaegerSpec{ + jaeger := &v1.Jaeger{ + Spec: v1.JaegerSpec{ Strategy: "production", - Storage: v1alpha1.JaegerStorageSpec{ + Storage: v1.JaegerStorageSpec{ Type: "memory", }, }, @@ -123,47 +123,47 @@ func TestStorageMemoryOnlyUsedWithAllInOneStrategy(t *testing.T) { } func TestSetSecurityToNoneByDefault(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestSetSecurityToNoneByDefault") + jaeger := v1.NewJaeger("TestSetSecurityToNoneByDefault") normalize(jaeger) - assert.Equal(t, v1alpha1.IngressSecurityNone, jaeger.Spec.Ingress.Security) + assert.Equal(t, v1.IngressSecurityNone, jaeger.Spec.Ingress.Security) } func TestSetSecurityToNoneWhenExplicitSettingToNone(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestSetSecurityToNoneWhenExplicitSettingToNone") - jaeger.Spec.Ingress.Security = v1alpha1.IngressSecurityNoneExplicit + jaeger := v1.NewJaeger("TestSetSecurityToNoneWhenExplicitSettingToNone") + jaeger.Spec.Ingress.Security = v1.IngressSecurityNoneExplicit normalize(jaeger) - assert.Equal(t, v1alpha1.IngressSecurityNone, jaeger.Spec.Ingress.Security) + assert.Equal(t, v1.IngressSecurityNone, jaeger.Spec.Ingress.Security) } func TestSetSecurityToOAuthProxyByDefaultOnOpenShift(t *testing.T) { viper.Set("platform", "openshift") defer viper.Reset() - jaeger := v1alpha1.NewJaeger("TestSetSecurityToOAuthProxyByDefaultOnOpenShift") + jaeger := v1.NewJaeger("TestSetSecurityToOAuthProxyByDefaultOnOpenShift") normalize(jaeger) - assert.Equal(t, v1alpha1.IngressSecurityOAuthProxy, jaeger.Spec.Ingress.Security) + assert.Equal(t, v1.IngressSecurityOAuthProxy, jaeger.Spec.Ingress.Security) } func TestSetSecurityToNoneOnNonOpenShift(t *testing.T) { - jaeger := v1alpha1.NewJaeger("TestSetSecurityToNoneOnNonOpenShift") - jaeger.Spec.Ingress.Security = v1alpha1.IngressSecurityOAuthProxy + jaeger := v1.NewJaeger("TestSetSecurityToNoneOnNonOpenShift") + jaeger.Spec.Ingress.Security = v1.IngressSecurityOAuthProxy normalize(jaeger) - assert.Equal(t, v1alpha1.IngressSecurityNone, jaeger.Spec.Ingress.Security) + assert.Equal(t, v1.IngressSecurityNone, jaeger.Spec.Ingress.Security) } func TestAcceptExplicitValueFromSecurityWhenOnOpenShift(t *testing.T) { viper.Set("platform", "openshift") defer viper.Reset() - jaeger := v1alpha1.NewJaeger("TestAcceptExplicitValueFromSecurityWhenOnOpenShift") - jaeger.Spec.Ingress.Security = v1alpha1.IngressSecurityNoneExplicit + jaeger := v1.NewJaeger("TestAcceptExplicitValueFromSecurityWhenOnOpenShift") + jaeger.Spec.Ingress.Security = v1.IngressSecurityNoneExplicit normalize(jaeger) - assert.Equal(t, v1alpha1.IngressSecurityNone, jaeger.Spec.Ingress.Security) + assert.Equal(t, v1.IngressSecurityNone, jaeger.Spec.Ingress.Security) } func TestNormalizeIndexCleaner(t *testing.T) { @@ -172,13 +172,13 @@ func TestNormalizeIndexCleaner(t *testing.T) { trueVar := true falseVar := false tests := []struct { - underTest v1alpha1.JaegerEsIndexCleanerSpec - expected v1alpha1.JaegerEsIndexCleanerSpec + underTest v1.JaegerEsIndexCleanerSpec + expected v1.JaegerEsIndexCleanerSpec }{ - {underTest: v1alpha1.JaegerEsIndexCleanerSpec{}, - expected: v1alpha1.JaegerEsIndexCleanerSpec{Image: "foo", Schedule: "55 23 * * *", NumberOfDays: 7, Enabled: &trueVar}}, - {underTest: v1alpha1.JaegerEsIndexCleanerSpec{Image: "bla", Schedule: "lol", NumberOfDays: 55, Enabled: &falseVar}, - expected: v1alpha1.JaegerEsIndexCleanerSpec{Image: "bla", Schedule: "lol", NumberOfDays: 55, Enabled: &falseVar}}, + {underTest: v1.JaegerEsIndexCleanerSpec{}, + expected: v1.JaegerEsIndexCleanerSpec{Image: "foo", Schedule: "55 23 * * *", NumberOfDays: 7, Enabled: &trueVar}}, + {underTest: v1.JaegerEsIndexCleanerSpec{Image: "bla", Schedule: "lol", NumberOfDays: 55, Enabled: &falseVar}, + expected: v1.JaegerEsIndexCleanerSpec{Image: "bla", Schedule: "lol", NumberOfDays: 55, Enabled: &falseVar}}, } for _, test := range tests { normalizeIndexCleaner(&test.underTest, "elasticsearch") @@ -192,13 +192,13 @@ func TestNormalizeSparkDependencies(t *testing.T) { trueVar := true falseVar := false tests := []struct { - underTest v1alpha1.JaegerDependenciesSpec - expected v1alpha1.JaegerDependenciesSpec + underTest v1.JaegerDependenciesSpec + expected v1.JaegerDependenciesSpec }{ - {underTest: v1alpha1.JaegerDependenciesSpec{}, - expected: v1alpha1.JaegerDependenciesSpec{Schedule: "55 23 * * *", Image: "foo", Enabled: &trueVar}}, - {underTest: v1alpha1.JaegerDependenciesSpec{Schedule: "foo", Image: "bla", Enabled: &falseVar}, - expected: v1alpha1.JaegerDependenciesSpec{Schedule: "foo", Image: "bla", Enabled: &falseVar}}, + {underTest: v1.JaegerDependenciesSpec{}, + expected: v1.JaegerDependenciesSpec{Schedule: "55 23 * * *", Image: "foo", Enabled: &trueVar}}, + {underTest: v1.JaegerDependenciesSpec{Schedule: "foo", Image: "bla", Enabled: &falseVar}, + expected: v1.JaegerDependenciesSpec{Schedule: "foo", Image: "bla", Enabled: &falseVar}}, } for _, test := range tests { normalizeSparkDependencies(&test.underTest, "elasticsearch") diff --git a/pkg/strategy/production.go b/pkg/strategy/production.go index 875f5eed0..448b6fc75 100644 --- a/pkg/strategy/production.go +++ b/pkg/strategy/production.go @@ -8,7 +8,7 @@ import ( batchv1beta1 "k8s.io/api/batch/v1beta1" "github.com/jaegertracing/jaeger-operator/pkg/account" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/config/sampling" "github.com/jaegertracing/jaeger-operator/pkg/config/ui" "github.com/jaegertracing/jaeger-operator/pkg/cronjob" @@ -19,7 +19,7 @@ import ( "github.com/jaegertracing/jaeger-operator/pkg/storage" ) -func newProductionStrategy(jaeger *v1alpha1.Jaeger) S { +func newProductionStrategy(jaeger *v1.Jaeger) S { c := S{typ: Production} collector := deployment.NewCollector(jaeger) query := deployment.NewQuery(jaeger) @@ -55,7 +55,7 @@ func newProductionStrategy(jaeger *v1alpha1.Jaeger) S { } // add the routes/ingresses - if viper.GetString("platform") == v1alpha1.FlagPlatformOpenShift { + if viper.GetString("platform") == v1.FlagPlatformOpenShift { if q := route.NewQueryRoute(jaeger).Get(); nil != q { c.routes = append(c.routes, *q) } diff --git a/pkg/strategy/production_test.go b/pkg/strategy/production_test.go index 4c6d0f73d..bcd2f5c42 100644 --- a/pkg/strategy/production_test.go +++ b/pkg/strategy/production_test.go @@ -10,7 +10,7 @@ import ( "github.com/stretchr/testify/assert" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/storage" ) @@ -21,7 +21,7 @@ func init() { func TestCreateProductionDeployment(t *testing.T) { name := "TestCreateProductionDeployment" - c := newProductionStrategy(v1alpha1.NewJaeger(name)) + c := newProductionStrategy(v1.NewJaeger(name)) assertDeploymentsAndServicesForProduction(t, name, c, false, false, false) } @@ -30,7 +30,7 @@ func TestCreateProductionDeploymentOnOpenShift(t *testing.T) { defer viper.Reset() name := "TestCreateProductionDeploymentOnOpenShift" - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) normalize(jaeger) c := newProductionStrategy(jaeger) @@ -40,7 +40,7 @@ func TestCreateProductionDeploymentOnOpenShift(t *testing.T) { func TestCreateProductionDeploymentWithDaemonSetAgent(t *testing.T) { name := "TestCreateProductionDeploymentWithDaemonSetAgent" - j := v1alpha1.NewJaeger(name) + j := v1.NewJaeger(name) j.Spec.Agent.Strategy = "DaemonSet" c := newProductionStrategy(j) @@ -50,8 +50,8 @@ func TestCreateProductionDeploymentWithDaemonSetAgent(t *testing.T) { func TestCreateProductionDeploymentWithUIConfigMap(t *testing.T) { name := "TestCreateProductionDeploymentWithUIConfigMap" - j := v1alpha1.NewJaeger(name) - j.Spec.UI.Options = v1alpha1.NewFreeForm(map[string]interface{}{ + j := v1.NewJaeger(name) + j.Spec.UI.Options = v1.NewFreeForm(map[string]interface{}{ "tracking": map[string]interface{}{ "gaID": "UA-000000-2", }, @@ -62,20 +62,20 @@ func TestCreateProductionDeploymentWithUIConfigMap(t *testing.T) { } func TestOptionsArePassed(t *testing.T) { - jaeger := &v1alpha1.Jaeger{ + jaeger := &v1.Jaeger{ TypeMeta: metav1.TypeMeta{ Kind: "Jaeger", - APIVersion: "io.jaegertracing/v1alpha1", + APIVersion: "jaegertracing.io/v1", }, ObjectMeta: metav1.ObjectMeta{ Name: "simple-prod", Namespace: "simple-prod-ns", }, - Spec: v1alpha1.JaegerSpec{ + Spec: v1.JaegerSpec{ Strategy: "production", - Storage: v1alpha1.JaegerStorageSpec{ + Storage: v1.JaegerStorageSpec{ Type: "elasticsearch", - Options: v1alpha1.NewOptions(map[string]interface{}{ + Options: v1.NewOptions(map[string]interface{}{ "es.server-urls": "http://elasticsearch.default.svc:9200", "es.username": "elastic", "es.password": "changeme", @@ -106,7 +106,7 @@ func TestOptionsArePassed(t *testing.T) { func TestDelegateProductionDependencies(t *testing.T) { // for now, we just have storage dependencies - j := v1alpha1.NewJaeger("TestDelegateProductionDependencies") + j := v1.NewJaeger("TestDelegateProductionDependencies") c := newProductionStrategy(j) assert.Equal(t, c.Dependencies(), storage.Dependencies(j)) } @@ -142,7 +142,7 @@ func assertDeploymentsAndServicesForProduction(t *testing.T, name string, s S, h ingresses := map[string]bool{} routes := map[string]bool{} - if viper.GetString("platform") == v1alpha1.FlagPlatformOpenShift { + if viper.GetString("platform") == v1.FlagPlatformOpenShift { routes[name] = false } else { ingresses[fmt.Sprintf("%s-query", name)] = false @@ -161,19 +161,19 @@ func assertDeploymentsAndServicesForProduction(t *testing.T, name string, s S, h } func TestSparkDependenciesProduction(t *testing.T) { - testSparkDependencies(t, func(jaeger *v1alpha1.Jaeger) S { + testSparkDependencies(t, func(jaeger *v1.Jaeger) S { return newProductionStrategy(jaeger) }) } func TestEsIndexCleanerProduction(t *testing.T) { - testEsIndexCleaner(t, func(jaeger *v1alpha1.Jaeger) S { + testEsIndexCleaner(t, func(jaeger *v1.Jaeger) S { return newProductionStrategy(jaeger) }) } func TestAgentSidecarIsInjectedIntoQueryForStreamingForProduction(t *testing.T) { - j := v1alpha1.NewJaeger("TestAgentSidecarIsInjectedIntoQueryForStreamingForProduction") + j := v1.NewJaeger("TestAgentSidecarIsInjectedIntoQueryForStreamingForProduction") c := newProductionStrategy(j) for _, dep := range c.Deployments() { if strings.HasSuffix(dep.Name, "-query") { diff --git a/pkg/strategy/streaming.go b/pkg/strategy/streaming.go index 3bf2d0254..a597f4ebe 100644 --- a/pkg/strategy/streaming.go +++ b/pkg/strategy/streaming.go @@ -7,7 +7,7 @@ import ( appsv1 "k8s.io/api/apps/v1" "github.com/jaegertracing/jaeger-operator/pkg/account" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/config/sampling" "github.com/jaegertracing/jaeger-operator/pkg/config/ui" "github.com/jaegertracing/jaeger-operator/pkg/cronjob" @@ -18,7 +18,7 @@ import ( "github.com/jaegertracing/jaeger-operator/pkg/storage" ) -func newStreamingStrategy(jaeger *v1alpha1.Jaeger) S { +func newStreamingStrategy(jaeger *v1.Jaeger) S { c := S{typ: Streaming} collector := deployment.NewCollector(jaeger) query := deployment.NewQuery(jaeger) @@ -62,7 +62,7 @@ func newStreamingStrategy(jaeger *v1alpha1.Jaeger) S { } // add the routes/ingresses - if viper.GetString("platform") == v1alpha1.FlagPlatformOpenShift { + if viper.GetString("platform") == v1.FlagPlatformOpenShift { if q := route.NewQueryRoute(jaeger).Get(); nil != q { c.routes = append(c.routes, *q) } diff --git a/pkg/strategy/streaming_test.go b/pkg/strategy/streaming_test.go index 5c560207a..f7bb250cb 100644 --- a/pkg/strategy/streaming_test.go +++ b/pkg/strategy/streaming_test.go @@ -10,7 +10,7 @@ import ( "github.com/stretchr/testify/assert" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/storage" ) @@ -21,7 +21,7 @@ func init() { func TestCreateStreamingDeployment(t *testing.T) { name := "TestCreateStreamingDeployment" - c := newStreamingStrategy(v1alpha1.NewJaeger(name)) + c := newStreamingStrategy(v1.NewJaeger(name)) assertDeploymentsAndServicesForStreaming(t, name, c, false, false, false) } @@ -30,7 +30,7 @@ func TestCreateStreamingDeploymentOnOpenShift(t *testing.T) { defer viper.Reset() name := "TestCreateStreamingDeploymentOnOpenShift" - jaeger := v1alpha1.NewJaeger(name) + jaeger := v1.NewJaeger(name) normalize(jaeger) c := newStreamingStrategy(jaeger) @@ -40,7 +40,7 @@ func TestCreateStreamingDeploymentOnOpenShift(t *testing.T) { func TestCreateStreamingDeploymentWithDaemonSetAgent(t *testing.T) { name := "TestCreateStreamingDeploymentWithDaemonSetAgent" - j := v1alpha1.NewJaeger(name) + j := v1.NewJaeger(name) j.Spec.Agent.Strategy = "DaemonSet" c := newStreamingStrategy(j) @@ -50,8 +50,8 @@ func TestCreateStreamingDeploymentWithDaemonSetAgent(t *testing.T) { func TestCreateStreamingDeploymentWithUIConfigMap(t *testing.T) { name := "TestCreateStreamingDeploymentWithUIConfigMap" - j := v1alpha1.NewJaeger(name) - j.Spec.UI.Options = v1alpha1.NewFreeForm(map[string]interface{}{ + j := v1.NewJaeger(name) + j.Spec.UI.Options = v1.NewFreeForm(map[string]interface{}{ "tracking": map[string]interface{}{ "gaID": "UA-000000-2", }, @@ -62,25 +62,25 @@ func TestCreateStreamingDeploymentWithUIConfigMap(t *testing.T) { } func TestStreamingOptionsArePassed(t *testing.T) { - jaeger := &v1alpha1.Jaeger{ + jaeger := &v1.Jaeger{ TypeMeta: metav1.TypeMeta{ Kind: "Jaeger", - APIVersion: "io.jaegertracing/v1alpha1", + APIVersion: "jaegertracing.io/v1", }, ObjectMeta: metav1.ObjectMeta{ Name: "simple-prod", Namespace: "simple-prod-ns", }, - Spec: v1alpha1.JaegerSpec{ + Spec: v1.JaegerSpec{ Strategy: "streaming", - Ingester: v1alpha1.JaegerIngesterSpec{ - Options: v1alpha1.NewOptions(map[string]interface{}{ + Ingester: v1.JaegerIngesterSpec{ + Options: v1.NewOptions(map[string]interface{}{ "kafka.topic": "mytopic", }), }, - Storage: v1alpha1.JaegerStorageSpec{ + Storage: v1.JaegerStorageSpec{ Type: "elasticsearch", - Options: v1alpha1.NewOptions(map[string]interface{}{ + Options: v1.NewOptions(map[string]interface{}{ "es.server-urls": "http://elasticsearch.default.svc:9200", "es.username": "elastic", "es.password": "changeme", @@ -119,7 +119,7 @@ func TestStreamingOptionsArePassed(t *testing.T) { func TestDelegateStreamingDependencies(t *testing.T) { // for now, we just have storage dependencies - j := v1alpha1.NewJaeger("TestDelegateStreamingDependencies") + j := v1.NewJaeger("TestDelegateStreamingDependencies") c := newStreamingStrategy(j) assert.Equal(t, c.Dependencies(), storage.Dependencies(j)) } @@ -155,7 +155,7 @@ func assertDeploymentsAndServicesForStreaming(t *testing.T, name string, s S, ha ingresses := map[string]bool{} routes := map[string]bool{} - if viper.GetString("platform") == v1alpha1.FlagPlatformOpenShift { + if viper.GetString("platform") == v1.FlagPlatformOpenShift { routes[name] = false } else { ingresses[fmt.Sprintf("%s-query", name)] = false @@ -174,19 +174,19 @@ func assertDeploymentsAndServicesForStreaming(t *testing.T, name string, s S, ha } func TestSparkDependenciesStreaming(t *testing.T) { - testSparkDependencies(t, func(jaeger *v1alpha1.Jaeger) S { + testSparkDependencies(t, func(jaeger *v1.Jaeger) S { return newStreamingStrategy(jaeger) }) } func TestEsIndexClenarStreaming(t *testing.T) { - testEsIndexCleaner(t, func(jaeger *v1alpha1.Jaeger) S { + testEsIndexCleaner(t, func(jaeger *v1.Jaeger) S { return newStreamingStrategy(jaeger) }) } func TestAgentSidecarIsInjectedIntoQueryForStreaming(t *testing.T) { - j := v1alpha1.NewJaeger("TestAgentSidecarIsInjectedIntoQueryForStreaming") + j := v1.NewJaeger("TestAgentSidecarIsInjectedIntoQueryForStreaming") c := newStreamingStrategy(j) for _, dep := range c.Deployments() { if strings.HasSuffix(dep.Name, "-query") { diff --git a/pkg/util/util.go b/pkg/util/util.go index 248b4743e..5ef966c64 100644 --- a/pkg/util/util.go +++ b/pkg/util/util.go @@ -1,14 +1,14 @@ package util import ( - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) // removeDuplicatedVolumes returns a unique list of Volumes based on Volume names. Only the first item is kept. -func removeDuplicatedVolumes(volumes []v1.Volume) []v1.Volume { - var results []v1.Volume +func removeDuplicatedVolumes(volumes []corev1.Volume) []corev1.Volume { + var results []corev1.Volume existing := map[string]bool{} for _, volume := range volumes { @@ -23,8 +23,8 @@ func removeDuplicatedVolumes(volumes []v1.Volume) []v1.Volume { } // removeDuplicatedVolumeMounts returns a unique list based on the item names. Only the first item is kept. -func removeDuplicatedVolumeMounts(volumeMounts []v1.VolumeMount) []v1.VolumeMount { - var results []v1.VolumeMount +func removeDuplicatedVolumeMounts(volumeMounts []corev1.VolumeMount) []corev1.VolumeMount { + var results []corev1.VolumeMount existing := map[string]bool{} for _, volumeMount := range volumeMounts { @@ -39,11 +39,11 @@ func removeDuplicatedVolumeMounts(volumeMounts []v1.VolumeMount) []v1.VolumeMoun } // Merge returns a merged version of the list of JaegerCommonSpec instances with most specific first -func Merge(commonSpecs []v1alpha1.JaegerCommonSpec) *v1alpha1.JaegerCommonSpec { +func Merge(commonSpecs []v1.JaegerCommonSpec) *v1.JaegerCommonSpec { annotations := make(map[string]string) - var volumeMounts []v1.VolumeMount - var volumes []v1.Volume - resources := &v1.ResourceRequirements{} + var volumeMounts []corev1.VolumeMount + var volumes []corev1.Volume + resources := &corev1.ResourceRequirements{} for _, commonSpec := range commonSpecs { // Merge annotations @@ -60,7 +60,7 @@ func Merge(commonSpecs []v1alpha1.JaegerCommonSpec) *v1alpha1.JaegerCommonSpec { mergeResources(resources, commonSpec.Resources) } - return &v1alpha1.JaegerCommonSpec{ + return &v1.JaegerCommonSpec{ Annotations: annotations, VolumeMounts: removeDuplicatedVolumeMounts(volumeMounts), Volumes: removeDuplicatedVolumes(volumes), @@ -68,12 +68,12 @@ func Merge(commonSpecs []v1alpha1.JaegerCommonSpec) *v1alpha1.JaegerCommonSpec { } } -func mergeResources(resources *v1.ResourceRequirements, res v1.ResourceRequirements) { +func mergeResources(resources *corev1.ResourceRequirements, res corev1.ResourceRequirements) { for k, v := range res.Limits { if _, ok := resources.Limits[k]; !ok { if resources.Limits == nil { - resources.Limits = make(v1.ResourceList) + resources.Limits = make(corev1.ResourceList) } resources.Limits[k] = v } @@ -82,7 +82,7 @@ func mergeResources(resources *v1.ResourceRequirements, res v1.ResourceRequireme for k, v := range res.Requests { if _, ok := resources.Requests[k]; !ok { if resources.Requests == nil { - resources.Requests = make(v1.ResourceList) + resources.Requests = make(corev1.ResourceList) } resources.Requests[k] = v } diff --git a/pkg/util/util_test.go b/pkg/util/util_test.go index b7d9ae17a..e078a6061 100644 --- a/pkg/util/util_test.go +++ b/pkg/util/util_test.go @@ -4,27 +4,23 @@ import ( "testing" "github.com/stretchr/testify/assert" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/api/resource" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func TestRemoveDuplicatedVolumes(t *testing.T) { - volumes := []v1.Volume{ - v1.Volume{ - Name: "volume1", - VolumeSource: v1.VolumeSource{HostPath: &v1.HostPathVolumeSource{Path: "/data1"}}, - }, - v1.Volume{ - Name: "volume2", - VolumeSource: v1.VolumeSource{HostPath: &v1.HostPathVolumeSource{Path: "/data2"}}, - }, - v1.Volume{ - Name: "volume1", - VolumeSource: v1.VolumeSource{HostPath: &v1.HostPathVolumeSource{Path: "/data3"}}, - }, - } + volumes := []corev1.Volume{{ + Name: "volume1", + VolumeSource: corev1.VolumeSource{HostPath: &corev1.HostPathVolumeSource{Path: "/data1"}}, + }, { + Name: "volume2", + VolumeSource: corev1.VolumeSource{HostPath: &corev1.HostPathVolumeSource{Path: "/data2"}}, + }, { + Name: "volume1", + VolumeSource: corev1.VolumeSource{HostPath: &corev1.HostPathVolumeSource{Path: "/data3"}}, + }} assert.Len(t, removeDuplicatedVolumes(volumes), 2) assert.Equal(t, "volume1", volumes[0].Name) @@ -33,20 +29,16 @@ func TestRemoveDuplicatedVolumes(t *testing.T) { } func TestRemoveDuplicatedVolumeMounts(t *testing.T) { - volumeMounts := []v1.VolumeMount{ - v1.VolumeMount{ - Name: "data1", - ReadOnly: false, - }, - v1.VolumeMount{ - Name: "data2", - ReadOnly: false, - }, - v1.VolumeMount{ - Name: "data1", - ReadOnly: true, - }, - } + volumeMounts := []corev1.VolumeMount{{ + Name: "data1", + ReadOnly: false, + }, { + Name: "data2", + ReadOnly: false, + }, { + Name: "data1", + ReadOnly: true, + }} assert.Len(t, removeDuplicatedVolumeMounts(volumeMounts), 2) assert.Equal(t, "data1", volumeMounts[0].Name) @@ -55,20 +47,20 @@ func TestRemoveDuplicatedVolumeMounts(t *testing.T) { } func TestMergeAnnotations(t *testing.T) { - generalSpec := v1alpha1.JaegerCommonSpec{ + generalSpec := v1.JaegerCommonSpec{ Annotations: map[string]string{ "name": "operator", "hello": "jaeger", }, } - specificSpec := v1alpha1.JaegerCommonSpec{ + specificSpec := v1.JaegerCommonSpec{ Annotations: map[string]string{ "hello": "world", // Override general annotation "prometheus.io/scrape": "false", }, } - merged := Merge([]v1alpha1.JaegerCommonSpec{specificSpec, generalSpec}) + merged := Merge([]v1.JaegerCommonSpec{specificSpec, generalSpec}) assert.Equal(t, "operator", merged.Annotations["name"]) assert.Equal(t, "world", merged.Annotations["hello"]) @@ -76,28 +68,23 @@ func TestMergeAnnotations(t *testing.T) { } func TestMergeMountVolumes(t *testing.T) { - generalSpec := v1alpha1.JaegerCommonSpec{ - VolumeMounts: []v1.VolumeMount{ - v1.VolumeMount{ - Name: "data1", - ReadOnly: true, - }, - }, + generalSpec := v1.JaegerCommonSpec{ + VolumeMounts: []corev1.VolumeMount{{ + Name: "data1", + ReadOnly: true, + }}, } - specificSpec := v1alpha1.JaegerCommonSpec{ - VolumeMounts: []v1.VolumeMount{ - v1.VolumeMount{ - Name: "data1", - ReadOnly: false, - }, - v1.VolumeMount{ - Name: "data2", - ReadOnly: false, - }, - }, + specificSpec := v1.JaegerCommonSpec{ + VolumeMounts: []corev1.VolumeMount{{ + Name: "data1", + ReadOnly: false, + }, { + Name: "data2", + ReadOnly: false, + }}, } - merged := Merge([]v1alpha1.JaegerCommonSpec{specificSpec, generalSpec}) + merged := Merge([]v1.JaegerCommonSpec{specificSpec, generalSpec}) assert.Equal(t, "data1", merged.VolumeMounts[0].Name) assert.Equal(t, false, merged.VolumeMounts[0].ReadOnly) @@ -105,28 +92,23 @@ func TestMergeMountVolumes(t *testing.T) { } func TestMergeVolumes(t *testing.T) { - generalSpec := v1alpha1.JaegerCommonSpec{ - Volumes: []v1.Volume{ - v1.Volume{ - Name: "volume1", - VolumeSource: v1.VolumeSource{HostPath: &v1.HostPathVolumeSource{Path: "/data3"}}, - }, - }, + generalSpec := v1.JaegerCommonSpec{ + Volumes: []corev1.Volume{{ + Name: "volume1", + VolumeSource: corev1.VolumeSource{HostPath: &corev1.HostPathVolumeSource{Path: "/data3"}}, + }}, } - specificSpec := v1alpha1.JaegerCommonSpec{ - Volumes: []v1.Volume{ - v1.Volume{ - Name: "volume1", - VolumeSource: v1.VolumeSource{HostPath: &v1.HostPathVolumeSource{Path: "/data1"}}, - }, - v1.Volume{ - Name: "volume2", - VolumeSource: v1.VolumeSource{HostPath: &v1.HostPathVolumeSource{Path: "/data2"}}, - }, - }, + specificSpec := v1.JaegerCommonSpec{ + Volumes: []corev1.Volume{{ + Name: "volume1", + VolumeSource: corev1.VolumeSource{HostPath: &corev1.HostPathVolumeSource{Path: "/data1"}}, + }, { + Name: "volume2", + VolumeSource: corev1.VolumeSource{HostPath: &corev1.HostPathVolumeSource{Path: "/data2"}}, + }}, } - merged := Merge([]v1alpha1.JaegerCommonSpec{specificSpec, generalSpec}) + merged := Merge([]v1.JaegerCommonSpec{specificSpec, generalSpec}) assert.Equal(t, "volume1", merged.Volumes[0].Name) assert.Equal(t, "/data1", merged.Volumes[0].VolumeSource.HostPath.Path) @@ -134,51 +116,51 @@ func TestMergeVolumes(t *testing.T) { } func TestMergeResourceLimits(t *testing.T) { - generalSpec := v1alpha1.JaegerCommonSpec{ - Resources: v1.ResourceRequirements{ - Limits: v1.ResourceList{ - v1.ResourceLimitsCPU: *resource.NewQuantity(1024, resource.BinarySI), - v1.ResourceLimitsEphemeralStorage: *resource.NewQuantity(123, resource.DecimalSI), + generalSpec := v1.JaegerCommonSpec{ + Resources: corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + corev1.ResourceLimitsCPU: *resource.NewQuantity(1024, resource.BinarySI), + corev1.ResourceLimitsEphemeralStorage: *resource.NewQuantity(123, resource.DecimalSI), }, }, } - specificSpec := v1alpha1.JaegerCommonSpec{ - Resources: v1.ResourceRequirements{ - Limits: v1.ResourceList{ - v1.ResourceLimitsCPU: *resource.NewQuantity(2048, resource.BinarySI), - v1.ResourceLimitsMemory: *resource.NewQuantity(1024, resource.BinarySI), + specificSpec := v1.JaegerCommonSpec{ + Resources: corev1.ResourceRequirements{ + Limits: corev1.ResourceList{ + corev1.ResourceLimitsCPU: *resource.NewQuantity(2048, resource.BinarySI), + corev1.ResourceLimitsMemory: *resource.NewQuantity(1024, resource.BinarySI), }, }, } - merged := Merge([]v1alpha1.JaegerCommonSpec{specificSpec, generalSpec}) + merged := Merge([]v1.JaegerCommonSpec{specificSpec, generalSpec}) - assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), merged.Resources.Limits[v1.ResourceLimitsCPU]) - assert.Equal(t, *resource.NewQuantity(1024, resource.BinarySI), merged.Resources.Limits[v1.ResourceLimitsMemory]) - assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), merged.Resources.Limits[v1.ResourceLimitsEphemeralStorage]) + assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), merged.Resources.Limits[corev1.ResourceLimitsCPU]) + assert.Equal(t, *resource.NewQuantity(1024, resource.BinarySI), merged.Resources.Limits[corev1.ResourceLimitsMemory]) + assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), merged.Resources.Limits[corev1.ResourceLimitsEphemeralStorage]) } func TestMergeResourceRequests(t *testing.T) { - generalSpec := v1alpha1.JaegerCommonSpec{ - Resources: v1.ResourceRequirements{ - Requests: v1.ResourceList{ - v1.ResourceRequestsCPU: *resource.NewQuantity(1024, resource.BinarySI), - v1.ResourceRequestsEphemeralStorage: *resource.NewQuantity(123, resource.DecimalSI), + generalSpec := v1.JaegerCommonSpec{ + Resources: corev1.ResourceRequirements{ + Requests: corev1.ResourceList{ + corev1.ResourceRequestsCPU: *resource.NewQuantity(1024, resource.BinarySI), + corev1.ResourceRequestsEphemeralStorage: *resource.NewQuantity(123, resource.DecimalSI), }, }, } - specificSpec := v1alpha1.JaegerCommonSpec{ - Resources: v1.ResourceRequirements{ - Requests: v1.ResourceList{ - v1.ResourceRequestsCPU: *resource.NewQuantity(2048, resource.BinarySI), - v1.ResourceRequestsMemory: *resource.NewQuantity(1024, resource.BinarySI), + specificSpec := v1.JaegerCommonSpec{ + Resources: corev1.ResourceRequirements{ + Requests: corev1.ResourceList{ + corev1.ResourceRequestsCPU: *resource.NewQuantity(2048, resource.BinarySI), + corev1.ResourceRequestsMemory: *resource.NewQuantity(1024, resource.BinarySI), }, }, } - merged := Merge([]v1alpha1.JaegerCommonSpec{specificSpec, generalSpec}) + merged := Merge([]v1.JaegerCommonSpec{specificSpec, generalSpec}) - assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), merged.Resources.Requests[v1.ResourceRequestsCPU]) - assert.Equal(t, *resource.NewQuantity(1024, resource.BinarySI), merged.Resources.Requests[v1.ResourceRequestsMemory]) - assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), merged.Resources.Requests[v1.ResourceRequestsEphemeralStorage]) + assert.Equal(t, *resource.NewQuantity(2048, resource.BinarySI), merged.Resources.Requests[corev1.ResourceRequestsCPU]) + assert.Equal(t, *resource.NewQuantity(1024, resource.BinarySI), merged.Resources.Requests[corev1.ResourceRequestsMemory]) + assert.Equal(t, *resource.NewQuantity(123, resource.DecimalSI), merged.Resources.Requests[corev1.ResourceRequestsEphemeralStorage]) } diff --git a/test/e2e/all_in_one_test.go b/test/e2e/all_in_one_test.go index 0ce4c3932..3771da1d6 100644 --- a/test/e2e/all_in_one_test.go +++ b/test/e2e/all_in_one_test.go @@ -15,13 +15,12 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/wait" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) const TrackingID = "MyTrackingId" func JaegerAllInOne(t *testing.T) { - t.Parallel() ctx := prepare(t) defer ctx.Cleanup() @@ -41,19 +40,19 @@ func allInOneTest(t *testing.T, f *framework.Framework, ctx *framework.TestCtx) } // create jaeger custom resource - exampleJaeger := &v1alpha1.Jaeger{ + exampleJaeger := &v1.Jaeger{ TypeMeta: metav1.TypeMeta{ Kind: "Jaeger", - APIVersion: "io.jaegertracing/v1alpha1", + APIVersion: "jaegertracing.io/v1", }, ObjectMeta: metav1.ObjectMeta{ Name: "my-jaeger", Namespace: namespace, }, - Spec: v1alpha1.JaegerSpec{ + Spec: v1.JaegerSpec{ Strategy: "allInOne", - AllInOne: v1alpha1.JaegerAllInOneSpec{ - Options: v1alpha1.NewOptions(map[string]interface{}{ + AllInOne: v1.JaegerAllInOneSpec{ + Options: v1.NewOptions(map[string]interface{}{ "log-level": "debug", "memory.max-traces": 10000, }), @@ -79,24 +78,24 @@ func allInOneWithUIConfigTest(t *testing.T, f *framework.Framework, ctx *framewo basePath := "/jaeger" - j := &v1alpha1.Jaeger{ + j := &v1.Jaeger{ TypeMeta: metav1.TypeMeta{ Kind: "Jaeger", - APIVersion: "io.jaegertracing/v1alpha1", + APIVersion: "jaegertracing.io/v1", }, ObjectMeta: metav1.ObjectMeta{ Name: "all-in-one-with-ui-config", Namespace: namespace, }, - Spec: v1alpha1.JaegerSpec{ + Spec: v1.JaegerSpec{ Strategy: "allInOne", - AllInOne: v1alpha1.JaegerAllInOneSpec{ - Options: v1alpha1.NewOptions(map[string]interface{}{ + AllInOne: v1.JaegerAllInOneSpec{ + Options: v1.NewOptions(map[string]interface{}{ "query.base-path": basePath, }), }, - UI: v1alpha1.JaegerUISpec{ - Options: v1alpha1.NewFreeForm(map[string]interface{}{ + UI: v1.JaegerUISpec{ + Options: v1.NewFreeForm(map[string]interface{}{ "tracking": map[string]interface{}{ "gaID": TrackingID, }, diff --git a/test/e2e/cassandra.go b/test/e2e/cassandra.go index aa5bb424d..cc409896c 100644 --- a/test/e2e/cassandra.go +++ b/test/e2e/cassandra.go @@ -10,7 +10,7 @@ import ( log "github.com/sirupsen/logrus" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) // Cassandra runs a test with Cassandra as the backing storage @@ -30,21 +30,21 @@ func cassandraTest(t *testing.T, f *framework.Framework, ctx *framework.TestCtx) return fmt.Errorf("could not get namespace: %v", err) } - j := &v1alpha1.Jaeger{ + j := &v1.Jaeger{ TypeMeta: metav1.TypeMeta{ Kind: "Jaeger", - APIVersion: "io.jaegertracing/v1alpha1", + APIVersion: "jaegertracing.io/v1", }, ObjectMeta: metav1.ObjectMeta{ Name: "with-cassandra", Namespace: namespace, }, - Spec: v1alpha1.JaegerSpec{ + Spec: v1.JaegerSpec{ Strategy: "allInOne", - Storage: v1alpha1.JaegerStorageSpec{ + Storage: v1.JaegerStorageSpec{ Type: "cassandra", - Options: v1alpha1.NewOptions(map[string]interface{}{"cassandra.servers": "cassandra.default.svc", "cassandra.keyspace": "jaeger_v1_datacenter1"}), - CassandraCreateSchema: v1alpha1.JaegerCassandraCreateSchemaSpec{ + Options: v1.NewOptions(map[string]interface{}{"cassandra.servers": "cassandra.default.svc", "cassandra.keyspace": "jaeger_v1_datacenter1"}), + CassandraCreateSchema: v1.JaegerCassandraCreateSchemaSpec{ Datacenter: "datacenter1", }, }, diff --git a/test/e2e/daemonset.go b/test/e2e/daemonset.go index d371d9e9b..9f8a05d16 100644 --- a/test/e2e/daemonset.go +++ b/test/e2e/daemonset.go @@ -13,12 +13,12 @@ import ( "github.com/operator-framework/operator-sdk/pkg/test/e2eutil" log "github.com/sirupsen/logrus" appsv1 "k8s.io/api/apps/v1" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/apimachinery/pkg/util/wait" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) // DaemonSet runs a test with the agent as DaemonSet @@ -38,21 +38,21 @@ func daemonsetTest(t *testing.T, f *framework.Framework, ctx *framework.TestCtx) return fmt.Errorf("could not get namespace: %v", err) } - j := &v1alpha1.Jaeger{ + j := &v1.Jaeger{ TypeMeta: metav1.TypeMeta{ Kind: "Jaeger", - APIVersion: "io.jaegertracing/v1alpha1", + APIVersion: "jaegertracing.io/v1", }, ObjectMeta: metav1.ObjectMeta{ Name: "agent-as-daemonset", Namespace: namespace, }, - Spec: v1alpha1.JaegerSpec{ + Spec: v1.JaegerSpec{ Strategy: "allInOne", - AllInOne: v1alpha1.JaegerAllInOneSpec{}, - Agent: v1alpha1.JaegerAgentSpec{ + AllInOne: v1.JaegerAllInOneSpec{}, + Agent: v1.JaegerAgentSpec{ Strategy: "DaemonSet", - Options: v1alpha1.NewOptions(map[string]interface{}{ + Options: v1.NewOptions(map[string]interface{}{ "log-level": "debug", }), }, @@ -84,41 +84,41 @@ func daemonsetTest(t *testing.T, f *framework.Framework, ctx *framework.TestCtx) Selector: &metav1.LabelSelector{ MatchLabels: selector, }, - Template: v1.PodTemplateSpec{ + Template: corev1.PodTemplateSpec{ ObjectMeta: metav1.ObjectMeta{ Labels: selector, }, - Spec: v1.PodSpec{ - Containers: []v1.Container{{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{{ Image: "jaegertracing/vertx-create-span:operator-e2e-tests", Name: "vertx-create-span", - Env: []v1.EnvVar{ - v1.EnvVar{ + Env: []corev1.EnvVar{ + corev1.EnvVar{ Name: "JAEGER_AGENT_HOST", - ValueFrom: &v1.EnvVarSource{ - FieldRef: &v1.ObjectFieldSelector{ + ValueFrom: &corev1.EnvVarSource{ + FieldRef: &corev1.ObjectFieldSelector{ FieldPath: "status.hostIP", }, }, }, }, - Ports: []v1.ContainerPort{ + Ports: []corev1.ContainerPort{ { ContainerPort: 8080, }, }, - ReadinessProbe: &v1.Probe{ - Handler: v1.Handler{ - HTTPGet: &v1.HTTPGetAction{ + ReadinessProbe: &corev1.Probe{ + Handler: corev1.Handler{ + HTTPGet: &corev1.HTTPGetAction{ Path: "/", Port: intstr.FromInt(8080), }, }, InitialDelaySeconds: 1, }, - LivenessProbe: &v1.Probe{ - Handler: v1.Handler{ - HTTPGet: &v1.HTTPGetAction{ + LivenessProbe: &corev1.Probe{ + Handler: corev1.Handler{ + HTTPGet: &corev1.HTTPGetAction{ Path: "/", Port: intstr.FromInt(8080), }, diff --git a/test/e2e/es_index_cleaner_test.go b/test/e2e/es_index_cleaner_test.go index a603f8639..5707cc55d 100644 --- a/test/e2e/es_index_cleaner_test.go +++ b/test/e2e/es_index_cleaner_test.go @@ -9,7 +9,7 @@ import ( framework "github.com/operator-framework/operator-sdk/pkg/test" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func EsIndexCleaner(t *testing.T) { @@ -27,23 +27,23 @@ func esIndexCleanerTest(t *testing.T, f *framework.Framework, testCtx *framework } name := "test-es-index-cleaner" - j := &v1alpha1.Jaeger{ + j := &v1.Jaeger{ TypeMeta: metav1.TypeMeta{ Kind: "Jaeger", - APIVersion: "io.jaegertracing/v1alpha1", + APIVersion: "jaegertracing.io/v1", }, ObjectMeta: metav1.ObjectMeta{ Name: name, Namespace: namespace, }, - Spec: v1alpha1.JaegerSpec{ + Spec: v1.JaegerSpec{ Strategy: "allInOne", - Storage: v1alpha1.JaegerStorageSpec{ + Storage: v1.JaegerStorageSpec{ Type: "elasticsearch", - Options: v1alpha1.NewOptions(map[string]interface{}{ + Options: v1.NewOptions(map[string]interface{}{ "es.server-urls": "http://elasticsearch.default.svc:9200", }), - EsIndexCleaner:v1alpha1.JaegerEsIndexCleanerSpec{ + EsIndexCleaner:v1.JaegerEsIndexCleanerSpec{ Schedule: "*/1 * * * *", }, }, diff --git a/test/e2e/jaeger_test.go b/test/e2e/jaeger_test.go index ed960ef62..698aa41ba 100644 --- a/test/e2e/jaeger_test.go +++ b/test/e2e/jaeger_test.go @@ -10,7 +10,7 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "github.com/jaegertracing/jaeger-operator/pkg/apis" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) var ( @@ -19,10 +19,10 @@ var ( ) func TestJaeger(t *testing.T) { - assert.NoError(t, framework.AddToFrameworkScheme(apis.AddToScheme, &v1alpha1.JaegerList{ + assert.NoError(t, framework.AddToFrameworkScheme(apis.AddToScheme, &v1.JaegerList{ TypeMeta: metav1.TypeMeta{ Kind: "Jaeger", - APIVersion: "io.jaegertracing/v1alpha1", + APIVersion: "jaegertracing.io/v1", }, })) diff --git a/test/e2e/production_test.go b/test/e2e/production_test.go index a6e0b5d39..c38cb61a7 100644 --- a/test/e2e/production_test.go +++ b/test/e2e/production_test.go @@ -5,15 +5,14 @@ import ( "fmt" "testing" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" framework "github.com/operator-framework/operator-sdk/pkg/test" "github.com/operator-framework/operator-sdk/pkg/test/e2eutil" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func SimpleProd(t *testing.T) { - t.Parallel() ctx := prepare(t) defer ctx.Cleanup() @@ -34,20 +33,20 @@ func simpleProd(t *testing.T, f *framework.Framework, ctx *framework.TestCtx) er } // create jaeger custom resource - exampleJaeger := &v1alpha1.Jaeger{ + exampleJaeger := &v1.Jaeger{ TypeMeta: metav1.TypeMeta{ Kind: "Jaeger", - APIVersion: "io.jaegertracing/v1alpha1", + APIVersion: "jaegertracing.io/v1", }, ObjectMeta: metav1.ObjectMeta{ Name: "simple-prod", Namespace: namespace, }, - Spec: v1alpha1.JaegerSpec{ + Spec: v1.JaegerSpec{ Strategy: "production", - Storage: v1alpha1.JaegerStorageSpec{ + Storage: v1.JaegerStorageSpec{ Type: "elasticsearch", - Options: v1alpha1.NewOptions(map[string]interface{}{ + Options: v1.NewOptions(map[string]interface{}{ "es.server-urls": "http://elasticsearch.default.svc:9200", }), }, @@ -67,11 +66,11 @@ func simpleProd(t *testing.T, f *framework.Framework, ctx *framework.TestCtx) er if err != nil { return err } - queryPod, err := GetPod(namespace, "simple-prod-query","jaegertracing/jaeger-query", f.KubeClient) + queryPod, err := GetPod(namespace, "simple-prod-query", "jaegertracing/jaeger-query", f.KubeClient) if err != nil { return err } - collectorPod, err := GetPod(namespace, "simple-prod-collector","jaegertracing/jaeger-collector", f.KubeClient) + collectorPod, err := GetPod(namespace, "simple-prod-collector", "jaegertracing/jaeger-collector", f.KubeClient) if err != nil { return err } diff --git a/test/e2e/sidecar.go b/test/e2e/sidecar.go index 59555b1bd..9b9b4d560 100644 --- a/test/e2e/sidecar.go +++ b/test/e2e/sidecar.go @@ -9,15 +9,15 @@ import ( "testing" "time" + framework "github.com/operator-framework/operator-sdk/pkg/test" + "github.com/operator-framework/operator-sdk/pkg/test/e2eutil" appsv1 "k8s.io/api/apps/v1" - "k8s.io/api/core/v1" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/apimachinery/pkg/util/wait" - framework "github.com/operator-framework/operator-sdk/pkg/test" - "github.com/operator-framework/operator-sdk/pkg/test/e2eutil" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" "github.com/jaegertracing/jaeger-operator/pkg/inject" ) @@ -38,20 +38,20 @@ func sidecarTest(t *testing.T, f *framework.Framework, ctx *framework.TestCtx) e return fmt.Errorf("could not get namespace: %v", err) } - j := &v1alpha1.Jaeger{ + j := &v1.Jaeger{ TypeMeta: metav1.TypeMeta{ Kind: "Jaeger", - APIVersion: "io.jaegertracing/v1alpha1", + APIVersion: "jaegertracing.io/v1", }, ObjectMeta: metav1.ObjectMeta{ Name: "agent-as-sidecar", Namespace: namespace, }, - Spec: v1alpha1.JaegerSpec{ + Spec: v1.JaegerSpec{ Strategy: "allInOne", - AllInOne: v1alpha1.JaegerAllInOneSpec{}, - Agent: v1alpha1.JaegerAgentSpec{ - Options: v1alpha1.NewOptions(map[string]interface{}{ + AllInOne: v1.JaegerAllInOneSpec{}, + Agent: v1.JaegerAgentSpec{ + Options: v1.NewOptions(map[string]interface{}{ "log-level": "debug", }), }, @@ -78,31 +78,31 @@ func sidecarTest(t *testing.T, f *framework.Framework, ctx *framework.TestCtx) e Selector: &metav1.LabelSelector{ MatchLabels: selector, }, - Template: v1.PodTemplateSpec{ + Template: corev1.PodTemplateSpec{ ObjectMeta: metav1.ObjectMeta{ Labels: selector, }, - Spec: v1.PodSpec{ - Containers: []v1.Container{{ + Spec: corev1.PodSpec{ + Containers: []corev1.Container{{ Image: "jaegertracing/vertx-create-span:operator-e2e-tests", Name: "vertx-create-span-sidecar", - Ports: []v1.ContainerPort{ + Ports: []corev1.ContainerPort{ { ContainerPort: 8080, }, }, - ReadinessProbe: &v1.Probe{ - Handler: v1.Handler{ - HTTPGet: &v1.HTTPGetAction{ + ReadinessProbe: &corev1.Probe{ + Handler: corev1.Handler{ + HTTPGet: &corev1.HTTPGetAction{ Path: "/", Port: intstr.FromInt(8080), }, }, InitialDelaySeconds: 1, }, - LivenessProbe: &v1.Probe{ - Handler: v1.Handler{ - HTTPGet: &v1.HTTPGetAction{ + LivenessProbe: &corev1.Probe{ + Handler: corev1.Handler{ + HTTPGet: &corev1.HTTPGetAction{ Path: "/", Port: intstr.FromInt(8080), }, diff --git a/test/e2e/simplest_test.go b/test/e2e/simplest_test.go index 443501269..089a571f6 100644 --- a/test/e2e/simplest_test.go +++ b/test/e2e/simplest_test.go @@ -5,15 +5,14 @@ import ( "fmt" "testing" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" framework "github.com/operator-framework/operator-sdk/pkg/test" "github.com/operator-framework/operator-sdk/pkg/test/e2eutil" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func SimplestJaeger(t *testing.T) { - t.Parallel() ctx := prepare(t) defer ctx.Cleanup() @@ -29,16 +28,16 @@ func simplest(t *testing.T, f *framework.Framework, ctx *framework.TestCtx) erro } // create jaeger custom resource - exampleJaeger := &v1alpha1.Jaeger{ + exampleJaeger := &v1.Jaeger{ TypeMeta: metav1.TypeMeta{ Kind: "Jaeger", - APIVersion: "io.jaegertracing/v1alpha1", + APIVersion: "jaegertracing.io/v1", }, ObjectMeta: metav1.ObjectMeta{ Name: "my-jaeger", Namespace: namespace, }, - Spec: v1alpha1.JaegerSpec{}, + Spec: v1.JaegerSpec{}, } err = f.Client.Create(goctx.TODO(), exampleJaeger, &framework.CleanupOptions{TestContext: ctx, Timeout: timeout, RetryInterval: retryInterval}) if err != nil { diff --git a/test/e2e/spark_dependencies_test.go b/test/e2e/spark_dependencies_test.go index 42ac51a58..f75fbc6c9 100644 --- a/test/e2e/spark_dependencies_test.go +++ b/test/e2e/spark_dependencies_test.go @@ -9,15 +9,15 @@ import ( "github.com/operator-framework/operator-sdk/pkg/test/e2eutil" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/jaegertracing/jaeger-operator/pkg/apis/io/v1alpha1" + "github.com/jaegertracing/jaeger-operator/pkg/apis/jaegertracing/v1" ) func SparkDependenciesElasticsearch(t *testing.T) { testCtx := prepare(t) defer testCtx.Cleanup() - storage := v1alpha1.JaegerStorageSpec{ + storage := v1.JaegerStorageSpec{ Type: "elasticsearch", - Options: v1alpha1.NewOptions(map[string]interface{}{ + Options: v1.NewOptions(map[string]interface{}{ "es.server-urls": "http://elasticsearch.default.svc:9200", }), } @@ -30,40 +30,40 @@ func SparkDependenciesCassandra(t *testing.T) { testCtx := prepare(t) defer testCtx.Cleanup() - storage := v1alpha1.JaegerStorageSpec{ + storage := v1.JaegerStorageSpec{ Type: "cassandra", - Options: v1alpha1.NewOptions(map[string]interface{}{"cassandra.servers": "cassandra.default.svc", "cassandra.keyspace": "jaeger_v1_datacenter1"}), - CassandraCreateSchema:v1alpha1.JaegerCassandraCreateSchemaSpec{Datacenter:"datacenter1", Mode: "prod"}, + Options: v1.NewOptions(map[string]interface{}{"cassandra.servers": "cassandra.default.svc", "cassandra.keyspace": "jaeger_v1_datacenter1"}), + CassandraCreateSchema:v1.JaegerCassandraCreateSchemaSpec{Datacenter:"datacenter1", Mode: "prod"}, } if err := sparkTest(t, framework.Global, testCtx, storage); err != nil { t.Fatal(err) } } -func sparkTest(t *testing.T, f *framework.Framework, testCtx *framework.TestCtx, storage v1alpha1.JaegerStorageSpec) error { +func sparkTest(t *testing.T, f *framework.Framework, testCtx *framework.TestCtx, storage v1.JaegerStorageSpec) error { namespace, err := testCtx.GetNamespace() if err != nil { return fmt.Errorf("could not get namespace: %v", err) } - storage.SparkDependencies = v1alpha1.JaegerDependenciesSpec{ + storage.SparkDependencies = v1.JaegerDependenciesSpec{ // run immediately Schedule: "*/1 * * * *", } name := "test-spark-deps" - j := &v1alpha1.Jaeger{ + j := &v1.Jaeger{ TypeMeta: metav1.TypeMeta{ Kind: "Jaeger", - APIVersion: "io.jaegertracing/v1alpha1", + APIVersion: "jaegertracing.io/v1", }, ObjectMeta: metav1.ObjectMeta{ Name: name, Namespace: namespace, }, - Spec: v1alpha1.JaegerSpec{ + Spec: v1.JaegerSpec{ Strategy: "allInOne", - AllInOne: v1alpha1.JaegerAllInOneSpec{}, + AllInOne: v1.JaegerAllInOneSpec{}, Storage: storage, }, } diff --git a/test/e2e/utils.go b/test/e2e/utils.go index d70b4ddea..93ef0b178 100644 --- a/test/e2e/utils.go +++ b/test/e2e/utils.go @@ -1,20 +1,19 @@ package e2e import ( - "errors" "fmt" "strings" - "k8s.io/api/core/v1" - "k8s.io/client-go/kubernetes" + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/kubernetes" ) // GetPod returns pod name -func GetPod(namespace, namePrefix, containsImage string, kubeclient kubernetes.Interface) (v1.Pod, error) { +func GetPod(namespace, namePrefix, containsImage string, kubeclient kubernetes.Interface) (corev1.Pod, error) { pods, err := kubeclient.CoreV1().Pods(namespace).List(metav1.ListOptions{}) if err != nil { - return v1.Pod{}, err + return corev1.Pod{}, err } for _, pod := range pods.Items { if strings.HasPrefix(pod.Name, namePrefix) { @@ -25,5 +24,5 @@ func GetPod(namespace, namePrefix, containsImage string, kubeclient kubernetes.I } } } - return v1.Pod{}, errors.New(fmt.Sprintf("could not find pod with image %s", containsImage)) + return corev1.Pod{}, fmt.Errorf("could not find pod with image %s", containsImage) } diff --git a/test/role.yaml b/test/role.yaml index 322da7eca..4e59ea7ce 100644 --- a/test/role.yaml +++ b/test/role.yaml @@ -77,3 +77,9 @@ rules: - elasticsearches verbs: - '*' +- apiGroups: + - jaegertracing.io + resources: + - '*' + verbs: + - '*'