From af13ed50479977f0fdf80c83012b4f5d5c872a6f Mon Sep 17 00:00:00 2001 From: whg517 Date: Fri, 6 Sep 2024 19:35:04 +0800 Subject: [PATCH] feat: add hive spark superset catalog and update exist (#24) --- catalog-template.yaml | 8 + catalog/commons-operator/index.yaml | 164 +++++++++----- catalog/hive-operator/index.yaml | 221 +++++++++++++++++++ catalog/secret-operator/index.yaml | 4 +- catalog/spark-k8s-operator/index.yaml | 298 ++++++++++++++++++++++++++ catalog/superset-operator/index.yaml | 212 ++++++++++++++++++ catalog/zookeeper-operator/index.yaml | 6 +- 7 files changed, 851 insertions(+), 62 deletions(-) create mode 100644 catalog/hive-operator/index.yaml create mode 100644 catalog/spark-k8s-operator/index.yaml create mode 100644 catalog/superset-operator/index.yaml diff --git a/catalog-template.yaml b/catalog-template.yaml index 8b142d4..e24ddba 100644 --- a/catalog-template.yaml +++ b/catalog-template.yaml @@ -10,3 +10,11 @@ references: image: quay.io/zncdatadev/zookeeper-operator-catalog:latest - name: hdfs-operator image: quay.io/zncdatadev/hdfs-operator-catalog:latest +- name: zookeeper-operator + image: quay.io/zncdatadev/zookeeper-operator-catalog:latest +- name: spark-k8s-operator + image: quay.io/zncdatadev/spark-k8s-operator-catalog:latest +- name: hive-operator + image: quay.io/zncdatadev/hive-operator-catalog:latest +- name: superset-operator + image: quay.io/zncdatadev/superset-operator-catalog:latest diff --git a/catalog/commons-operator/index.yaml b/catalog/commons-operator/index.yaml index e3dff02..013e30c 100644 --- a/catalog/commons-operator/index.yaml +++ b/catalog/commons-operator/index.yaml @@ -115,16 +115,6 @@ properties: group: authentication.zncdata.dev kind: AuthenticationClass version: v1alpha1 -- type: olm.gvk - value: - group: database.zncdata.dev - kind: Database - version: v1alpha1 -- type: olm.gvk - value: - group: database.zncdata.dev - kind: DatabaseConnection - version: v1alpha1 - type: olm.gvk value: group: s3.zncdata.dev @@ -157,37 +147,81 @@ properties: }, "name": "authenticationclass-sample" }, - "spec": null - }, - { - "apiVersion": "database.zncdata.dev/v1alpha1", - "kind": "Database", - "metadata": { - "labels": { - "app.kubernetes.io/created-by": "commons-operator", - "app.kubernetes.io/instance": "database-sample", - "app.kubernetes.io/managed-by": "kustomize", - "app.kubernetes.io/name": "database", - "app.kubernetes.io/part-of": "commons-operator" - }, - "name": "database-sample" - }, - "spec": null - }, - { - "apiVersion": "database.zncdata.dev/v1alpha1", - "kind": "DatabaseConnection", - "metadata": { - "labels": { - "app.kubernetes.io/created-by": "commons-operator", - "app.kubernetes.io/instance": "databaseconnection-sample", - "app.kubernetes.io/managed-by": "kustomize", - "app.kubernetes.io/name": "databaseconnection", - "app.kubernetes.io/part-of": "commons-operator" - }, - "name": "databaseconnection-sample" - }, - "spec": null + "spec": { + "provider": { + "ldap": { + "bindCredentials": { + "scope": { + "node": false, + "pod": true, + "services": [ + "foo" + ] + }, + "secretClass": "ldap-credentials" + }, + "hostname": "ldap.example.com", + "ldapFieldNames": { + "email": "mail", + "givenName": "cn", + "group": "cn", + "surname": "cn", + "uid": "cn" + }, + "port": 389, + "searchBase": "ou=people,dc=example,dc=com", + "searchFilter": "(uid={username})", + "tls": { + "verification": { + "mutual": { + "certSecretClass": "tls" + }, + "none": {}, + "server": { + "caCert": { + "secretClass": "tls", + "webPIK": {} + } + } + } + } + }, + "oidc": { + "hostname": "keycloak.example.com", + "port": 8080, + "principalClaim": "preferred_username", + "provisioner": "keycloak", + "rootPath": "/auth", + "scopes": [ + "openid", + "email", + "profile" + ], + "tls": { + "verification": { + "mutual": { + "certSecretClass": "tls" + }, + "none": {}, + "server": { + "caCert": { + "secretClass": "tls", + "webPIK": {} + } + } + } + } + }, + "static": { + "userCredentialsSecret": { + "name": "static-credentials" + } + }, + "tls": { + "clientCertSecretClass": "tls" + } + } + } }, { "apiVersion": "s3.zncdata.dev/v1alpha1", @@ -202,7 +236,10 @@ properties: }, "name": "s3bucket-sample" }, - "spec": null + "spec": { + "bucketName": "mybucket", + "connection": "s3connection-sample" + } }, { "apiVersion": "s3.zncdata.dev/v1alpha1", @@ -217,12 +254,40 @@ properties: }, "name": "s3connection-sample" }, - "spec": null + "spec": { + "credentials": { + "host": "s3.example.com", + "port": 443, + "region": "us-west-1", + "scope": { + "node": false, + "pod": true, + "services": [ + "foo" + ] + }, + "secretClass": "s3-credentials", + "tls": { + "verification": { + "mutual": { + "certSecretClass": "tls" + }, + "none": {}, + "server": { + "caCert": { + "secretClass": "tls", + "webPIK": {} + } + } + } + } + } + } } ] capabilities: Basic Install categories: Big Data - createdAt: "2024-08-29T12:19:51Z" + createdAt: "2024-09-06T10:36:20Z" operators.operatorframework.io/builder: operator-sdk-v1.35.0 operators.operatorframework.io/project_layout: go.kubebuilder.io/v4 apiServiceDefinitions: {} @@ -234,17 +299,6 @@ properties: kind: AuthenticationClass name: authenticationclasses.authentication.zncdata.dev version: v1alpha1 - - description: DatabaseConnection is the Schema for the databaseconnections - API - displayName: Database Connection - kind: DatabaseConnection - name: databaseconnections.database.zncdata.dev - version: v1alpha1 - - description: Database is the Schema for the databases API - displayName: Database - kind: Database - name: databases.database.zncdata.dev - version: v1alpha1 - description: S3Bucket is the Schema for the s3buckets API displayName: S3 Bucket kind: S3Bucket diff --git a/catalog/hive-operator/index.yaml b/catalog/hive-operator/index.yaml new file mode 100644 index 0000000..48bbd7b --- /dev/null +++ b/catalog/hive-operator/index.yaml @@ -0,0 +1,221 @@ +--- +defaultChannel: stable +description: |+ + # hive-operator + + // TODO(user): Add simple overview of use/purpose + + ## Description + + // TODO(user): An in-depth paragraph about your project and overview of use + + ## Getting Started + + You’ll need a Kubernetes cluster to run against. You can use [KIND](https://sigs.k8s.io/kind) to get a local cluster for testing, or run against a remote cluster. + **Note:** Your controller will automatically use the current context in your kubeconfig file (i.e. whatever cluster `kubectl cluster-info` shows). + + ### Running on the cluster + + 1. Install Instances of Custom Resources: + + ```sh + kubectl apply -f config/samples/ + ``` + + 2. Build and push your image to the location specified by `IMG`: + + ```sh + make docker-build docker-push IMG=/hive-operator:tag + ``` + + 3. Deploy the controller to the cluster with the image specified by `IMG`: + + ```sh + make deploy IMG=/hive-operator:tag + ``` + + + ### Uninstall CRDs + + To delete the CRDs from the cluster: + + ```sh + make uninstall + ``` + + ### Undeploy controller + + UnDeploy the controller from the cluster: + + ```sh + make undeploy + ``` + + ## Contributing + + // TODO(user): Add detailed information on how you would like others to contribute to this project + + ### How it works + + This project aims to follow the Kubernetes [Operator pattern](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/). + + It uses [Controllers](https://kubernetes.io/docs/concepts/architecture/controller/), + which provide a reconcile function responsible for synchronizing resources until the desired state is reached on the cluster. + + ### Test It Out + + + 1. Install the CRDs into the cluster: + + ```sh + make install + ``` + + 2. Run your controller (this will run in the foreground, so switch to a new terminal if you want to leave it running): + + ```sh + make run + ``` + + + **NOTE:** You can also run this in one step by running: `make install run` + + ### Modifying the API definitions + + If you are editing the API definitions, generate the manifests such as CRs or CRDs using: + + ```sh + make manifests + ``` + + **NOTE:** Run `make --help` for more information on all potential `make` targets + + More information can be found via the [Kubebuilder Documentation](https://book.kubebuilder.io/introduction.html) + + ## License + + Copyright 2023 zncdatadev. + + 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. + +icon: + base64data: <?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns="http://www.w3.org/2000/svg" height="900" width="1e3" version="1.1" xmlns:cc="http://creativecommons.org/ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" viewBox="0 0 1000 900">
 <g stroke="#fdee21" stroke-width="5.1286" transform="translate(-.53268 66.8)" fill-rule="evenodd">
  <path d="m597.33 637.79v192.85h47.346v-88.632l9.7674 0.18273v88.45h47.881v-192.85h-47.881v71.552h-9.7674v-71.552z"/>
  <path d="m761.25 637.79h-46.116v192.85h46.116z"/>
  <path d="m768.8 637.79 36.429 192.85h54.984l36.429-192.85h-48.951l-12.067 82.517c-1.0055 3.1605-4.402 3.1605-5.0089 0l-12.06-82.52z"/>
  <path d="m997.97 637.79h-91.538v192.85h91.538v-50.569l-50.898-0.43357 0.00017-21.679h24.248v-50.204h-24.248l-0.00017-19.397h50.898z"/>
 </g>
 <g transform="translate(-.53268 66.8)">
  <path d="m503.66 52.952c-7.71-21.115-272.92-124.22-276.31-112.9-48.7 12.695-68.52 68.826-102.02 104.38l-74.393-4.261c-32.771 42.142-49.967 85.199-38.258 129.95 42.002 56.906 90.76 105.33 121.15 176.81 2.402 33.692 145.82 3.533 176.56-3.1364-41.992 30.059-78.561 76.651-62.846 210.84 14.346 63.014 24.159 133.37 151.4 204.64 16.75 9.3816 51.407 20.207 72.838 28.098 20.495 9.4012 44.461 13.264 112.07-7.4123 39.124-16.863 81.365-27.022 119.65-43.844l-46.017 2.1595c-63.369 1.3787-112.29 6.1057-127.38-11.6l-58.32-100.68 34-66.04c47.056 4.8263 62.675 42.986 104.15 57.518l48.885-36.215c141.99 83.816 198.48-53.12 214.67-159.77-1.7276-43.392-93.952 13.611-88.362-6.6789 2.1662-46.644-35.854-107.67-60.42-155.22l28.43-110.01c12.9-11.49-59.72-133.86-119.02-149.12-52.03-13.391-130.46 52.492-130.46 52.492z" fill-rule="evenodd" fill="#fdee21"/>
 </g>
 <g fill-rule="evenodd">
  <g fill="#c8c037" transform="translate(-.53268 66.8)">
   <path d="m736.92 286.75c0.50927 11.816 0.45216 26.187 1.5941 35.15-0.19663 6.8382-5.3227 7.0888-9.5645 8.5212l27.631 10.119c5.4855 9.2313 9.8941 18.463 14.347 27.694 5.1652 22.708 1.3105 23.357-2.1254 25.031-10.027 0.10212-20.025 0.12088-29.358-1.864 4.181 2.2066 5.1006 3.8152 5.543 6.642 0.81556 5.2117-2.5407 12.329-8.0669 19.188 8.1718 4.534 23.071 8.9698 34.14 13.181l12.62-28.093c-5.7151-41.271-23.045-79.309-46.76-115.57z"/>
   <path d="m788.49 425.18c15.324 6.3872 36.495 4.5146 65.848-10.613 4.3653-3.1043 8.4311-1.2485 0.61937 3.8577-38.499 34.547-56.927 17.265-66.467 6.7552z"/>
   <path d="m857.28 410.04c4.5523 8.7165 1.7942 15.805 0.26568 23.167-4.7534 37.449-16.423 67.056-39.321 97.994-74.478 119.74-149.67 44.817-209.62-3.9455l-24.798 62.137c-1.3162 5.4464-6.7903 9.688 31.937 26.738l39.452-27.867c150.46 114.48 257.08-160.24 202.08-178.22z"/>
   <path d="m626.75 517.04c-10.151 0.72442-40.361 10.997-41.706 16.946l13.902-20.712z"/>
   <path d="m607.01 390.07c1.8598 0 10.788 2.3971 9.8302 1.864-1.3698-0.76256-0.15272 12.519 2.6568 19.439l-10.893 23.7c20.865-24.063 53.858-22.462 84.486-25.564l-14.612-9.0537c2.5384-8.4664-0.45059-15.165-1.8598-22.368z"/>
   <path d="m658.28 318.71c-22.387 6.8632-43.816 18.075-58.203 41.976 10.976-39.395 13.213-37.899 16.757-39.846 15.351-6.8651 27.922-2.5864 41.446-2.1303z"/>
  </g>
  <g fill="#fcf6a0" transform="translate(-.53268 66.8)">
   <path d="m538.73 780.45c-27.07 29.87-87.47-2.26-137.63-18.64-127.46-81.05-152.36-157.35-154.09-232.2-6.5535-107.22 26.37-169.52 68.014-184.27-27.561 53.129-40.41 148.5-27.631 219.42 10.315 39.455 10.529 106 76.545 141.62 32.327 18.199 23.571 32.368 45.431 49.413 23.955 18.679 90.747 36.437 129.36 24.658z"/>
   <path d="m579.17 284.94c-45.831-64.991-110.29-89.387-182.98-92.053 14.568-4.7488 29.136-7.2216 43.704-14.246 3.5675-3.7484 2.4012-10.344 1.0627-17.042-69.97-18.27-114.13-40.85-170.03-61.781l150.91 36.215c101.91 3.8724 93.158 29.032 157.34 148.91z"/>
   <path d="m628.24 253.6c-33.87-48.35-66.72-107.03-111.31-144.35-107.64-48.584-214.12-84.666-338.91-117.5l39.827-51.216c132.42 30.227 256.8 80.808 368.21 164.19 18.849 47.66 31.419 95.383 42.173 148.87z"/>
   <path d="m696.52 168.16s-18.988-42.599-28.233-58.866c-21.446-23.766-32.29-68.054-76.213-88.922 13.892 3.7515 23.399-0.7183 51.759 24.992l44.669 84.734z"/>
   <path d="m720.14 241.96c4.3792-36.908 12.695-96.11 3.1517-119.5-26.55-35.624-53.29-72.446-80.04-106.63-4.43-4.123-7.62-9.7186-11.11-14.084 37.61 9.744 76.86 35.894 129.79 139.13z"/>
  </g>
  <g transform="translate(-.53268 66.8)">
   <path d="m562.02 246.32c-14.98-11.79-28.33-53.49-51.03-62.16-21.011-1.7577-28.715-8.3682-56.344-2.7386 10.021-5.0213 19.482-11.446 30.134-14.885 7.2152-1.7032 13.983 0.18382 20.867 1.1334 1.6999-0.80357 2.8139-1.8029 2.3983-3.3133-27.812-17.187-84.866-17.432-123.38-27.243 44.699 1.4962 94.156-0.9815 127.75 9.7912 27.013 23.973 35.788 69.119 49.605 99.415z"/>
   <path d="m643.93 45.227c6.2011 0.56336 39.574 53.353 41.142 62.137 2.7751 19.202 9.6196 40.728 11.46 60.819-5.4968-19.269-11.486-38.537-18.974-57.806-2.1898-5.3062-7.7241-17.302-23.107-34.269-7.1628-11.959-8.7092-21.359-10.52-30.88z"/>
   <path d="m757.02 332.75h-14.278l15.781 4.1424z"/>
   <path d="m659.6 318.49c-14.358-1.7651-29.091-1.9991-43.448 1.1565-5.8522 7.8608-6.2554 15.856-8.813 23.245 17.454-19.236 24.38-20.412 52.261-24.401z"/>
   <path d="m855.42 417.77c-7.99 6.3771-8.7884 12.379-32.413 19.572-17.228 4.074-26.961-2.8314-35.07-12.116 12.294 3.5217 14.259 12.81 47.225 2.3966z"/>
   <path d="m783.82 421.76c-5.7504 15.812-11.949 31.791-18.199 46.6-14.883 17.454-8.5402 7.5079-30.819 34.617 7.1285-10.998 16.4-21.566 21.254-33.02 3.4091-7.5422 7.6532-15.543 9.5323-22.244-5.9074-2.95-17.999-3.1834-19.639-2.1247-19.808 11.683-23.382 24.047-35.059 36.086 8.4637-13.53 15.693-28.298 25.505-40.476 1.1181-1.5806 8.3826-1.8863 12.849-2.8189-6.9404-1.1908-19.786-3.6848-20.82-3.572-12.922 3.1053-20.163 14.361-29.756 21.836 6.9939-10.098 13.436-20.612 22.317-29.292 0.8785-1.0208 24.883 1.0822 37.324 6.0466l0.2468 4.9491 7.0633 2.8512 5.3136-13.314z"/>
   <path d="m627.07 517.09c-3.1882-1.0895-31.35-4.7112-31.35-3.8611-10.813 7.6957-12.453 15.059-12.221 21.436 17.989-17.697 17.319-17.747 43.572-17.575z"/>
   <path d="m605.68 389.81s20.322-2.9626 19.926-1.0652c-1.4722 7.0504 2.4876 24.233 2.9225 21.836l-11.424 9.32c23.926-12.029 49.113-9.6117 74.656-11.45 0 0-21.507-5.9381-20.192-6.1246 4.7977-0.6803-1.2772-22.43-2.9225-22.901 4.0915-1.3847 8.0873-2.4285 12.221-3.4617-30.756-8.0483-48.541-3.3059-75.188 13.847z"/>
   <path d="m781.56 404.98-4.5166 2.2634c-0.6408-13.231-14.851-12.26-26.834-12.382l-9.8302-2.3966c2.9889 2.7664 12.229 2.5495 8.5018 8.5212-3.1367 1.6765-4.5798 8.87-6.3763 14.912l-5.3136 0.26628c9.3867 3.6684 18.095 6.8836 28.428 11.184l6.1106 0.932 14.612-7.8555z"/>
  </g>
  <g fill="#fff" transform="translate(-.53268 66.8)">
   <path d="m646.86 396.06c-2.2872-4.5248-13.794-3.8824-16.275-0.95484-2.0158 2.3788-0.12514 17.642 2.4595 15.068 3.7368-3.2849 8.6176-4.6588 14.48-4.3938 0.73904-2.82 0.47742-5.8648-0.66421-9.7194z"/>
   <path d="m757.21 418.8c1.0816-0.79113 3.3689-8.4434 2.6301-10.733-1.5117-5.4032-12.212-4.2659-12.212-4.2659-2.6108 1.5363-4.8989 9.9596-3.9448 12.739 0.45543 2.3526 11.809 3.1025 13.526 2.2595z"/>
  </g>
  <g transform="translate(-.53268 66.8)">
   <path d="m299.64 682.84 6.7596 0.66112c40.071 19.675 106.05 48.847 201.57 33.171l14.988 23.584c-42.067 20.442-87.312 15.738-129.71 17.172z"/>
   <path d="m242.11 527.3 20.073 84.268c53.74 33.593 145.54 72.07 222.06 68.965l-16.91-38.8c-159.73-33.92-173.24-76.8-225.22-114.44z"/>
   <path d="m292.06 354.69c9.8106 65.302 22.907 114.81 79.69 156.28 34.804 25.03 69.351 49.954 111.37 70.524 0 0-3.6836 19.171-6.7631 18.829-125.05-13.89-216.6-117.58-227.69-164.94 10.741-36.329 26.149-59.021 43.389-80.693z"/>
   <path d="m352.17 317.69c16.664 72.376 56.397 145.68 95.889 212.18 14.477 18.369 18.266 26.475 40.579 37.659 30.159 9.5492 51.486 7.1119 73.377 5.6756-5.9982-11.102-11.329-22.706-18.217-33.14-49.018-38.765-26.364-74.06-13.344-96.406-27.256-6.887-63.37-21.525-68.345-40.778-7.9992-62.271-3.9373-82.025 4.0685-114.01-36.909 7.7822-74.309 15.494-114.01 28.82z"/>
   <path style="color-rendering:auto;text-decoration-color:#000000;color:#000000;isolation:auto;mix-blend-mode:normal;shape-rendering:auto;solid-color:#000000;block-progression:tb;text-decoration-line:none;image-rendering:auto;white-space:normal;text-indent:0;text-transform:none;text-decoration-style:solid" d="m216.77-66.742c-12.131 7.9248-23.818 19.256-36.391 32.135-20.843 21.575-34.699 42.621-55.915 58.224-4.2432 3.6588-16.151 9.5511-31.121 10.425-7.052 0.352-11.646 1.519-24.604-0.108-11.428-6.188-22.285-2.164-32.881 10.51-11.619 16.709-26.334 48.437-32.453 68.41-12.611 50.937 19.541 92.905 50.374 125.25 27.429 26.796 43.243 43.542 54.505 68.107 8.527 15.933 14.844 37.799 21.683 53.13 2.4661 4.8605 1.9534 4.8352 8.5913 6.3 14.333 3.0588 34.215 3.0828 51.915 4.6041 7.6583 0.10691 18.175-0.17813 28.14-1.2168 13.731-2.5928 29.863-5.1333 43.384-9.8098 13.213-3.2535 24.985-7.7592 35.597-11.907-1.3686 4.6442-11.478 9.1153-15.268 15.002-35.97 51.49-45.823 97.308-39.561 169.6 3.5425 32.042 10.896 58.605 21.992 88.997 5.0775 13.908 15.882 35.934 26.236 50.565 30.79 43.506 99.672 99.374 195.56 120.88 16.729 2.2866 35.715 1.067 53.571-3.6882 47.326-14.346 143.78-48.275 143.78-48.275s-85.619 7.0828-124.83 3.2058c-9.0778-1.4195-19.081-1.9011-25.405-8.0872-1.0608-1.3694-4.9144-9.1318-2.4258-9.2015 3.3952-0.095 13.142-4.14 28.191-5.4821-32.129-3.4591-31.671-3.418-34.016-9.2706-3.6471-9.0847-9.2292-21.502-14.977-32.367 14.118 1.1911 45.376 2.9455 55.984-8.0025 0 0-18.497 2.1356-34.843 0.2184-5.5072-0.64595-14.891-3.9946-17.71-5.0297-7.3383-2.858-13.38-3.7456-14.788-5.6091-2.5483-6.4856-4.2751-8.6672-7.3506-17.356-4.1659-11.504-4.4964-24.337-5.2895-36.083 10.693 13.18 24.318 24.275 42.356 29.941 0.23141-0.48776 23.4 10.072 40.226 4.642l3.4886-1.1254c0 0.31134-11.148 0.9767-15.237-1.0474-34.219-14.545-39.37-27.276-44.895-33.599l-14.777-22.133c4.4943-8.9608 7.0351-9.3013 12.989-9.3842 18.011 2.0006 25.848 3.5399 36.807 0.89587 7.4053 15.24 9.4062 30.571 26.265 41.662 56.166 16.672 68.369-4.951 81.973-24.057 40.412 29.658 106.2 38.803 151.89 0.51478 58.086-67.212 76.476-173.17 71.325-179.22-7.2544-12.307-16.772-24.999-24.945-23.245-29.13 7.952-39.871 22.73-68.735 19.359 3.4377-0.19431 9.2187-0.28734 9.2628-0.61508 2.2238-24.441-0.17883-36.267-1.2518-38.297-8.759-19.317-20.261-39.646-28.278-54.881-2.0668-3.1607-8.1367-27.165-18.308-36.648-4.3623-3.7245-15.039-13.546-15.039-13.546l-0.90484 10.439s4.1739 0.63032 5.7624 7.0973c6.0222 24.517 36.687 82.485 38.938 85.263 10.868 17.545 1.1045 39.401 9.3673 51.663 0.7938 1.5578 16.857-0.1365 29.307 0.62845 20.473-4.4034 19.609-13.426 37.294-14.782 11.913-0.91347 13.108 21.46 12.951 23.196-2.22 24.704-9.735 53.427-21.236 79.658-23.912 46.069-50.691 87.446-88.67 93.216-46.326 8.0952-70.399-12.158-95.512-25.055l-9.6068 8.1934c-32.637 32.501-71.389 29.614-87.239-12.851-7.8901-16.473-18.172-26.569-26.976-40.7l-46.688 33.627c-3.8865 7.9708-8.6652 20.54-14.47 34.58-4.0357 9.761-7.4199 26.525-7.1995 40.456-5.9847 10.195 20.729 51.542 37.609 76.692 4.9811 7.4212 14.279 20.385 14.59 21.193 3.3476 8.6831 10.679 16.349 11.124 17.284 31.337 40.872-39.531 31.46-54.167 28.991-28.876-4.601-57.121-16.663-83.67-32.792-1.5406-0.93601-3.0757-1.8853-4.6047-2.848-31.551-19.866-60.581-45.283-85.264-70.423-14.718-16.666-28.732-50.827-39.083-75.045-15.513-58.226-37.776-159.15 22.532-235.63 3.8228-4.3717 7.9478-11.65 11.46-13.09 17.918-12.119 37.375-20.379 58.298-24.966l-2.1122-13.563c-10.449 2.3741-45.633 15.243-55.581 20.629-22.623 6.5582-41.388 13.406-70.22 20.625-9.3724 1.1468-18.592 1.1674-27.579-0.0535-20.741-2.8178-56.094-0.3007-58.349-2.3956-14.044-19.585-17.889-54.676-30.703-73.456l-0.1512-0.1872-0.16231-0.17827c-7.47-10.04-16.177-18.23-24.752-26.75-30.708-30.51-56.991-60.01-64.348-91.27-1.85-9.23-6.614-18.79-4.082-46.1l0.04669-0.1337 0.04447-0.13371c7.388-25.513 19.407-46.31 39.806-67.153 21.228 0.34267 42.24 0.809 58.607 3.9355 7.5089 1.2562 23.124 3.2959 39.252 9.304 40.822 15.207 94.76 40.209 94.76 40.209-40.488-22.236-85.761-51.115-114.35-56.943-4.2536-0.60217-6.8679-2.5426-8.1311-5.93 42.999-25.264 50.865-55.009 79.147-81.686 12.925-5.6262 17.965-8.4984 28.947-9.6917 101.57 16.06 165.51 56.515 216.09 83.566 20.529 11.164 39.191 19.606 57.015 29.773 15.624 5.1391 62.771 40.734 76.569 59.925 14.017 29.595 24.251 61.563 33.585 92.411 6.6931 31.375 12.564 44.102 12.564 44.102s-5.6883-26.243-4.7403-30.958c5.8976 2.2038 19.841 6.5574 25.621 5.881 0 0-25.818-13.346-29.201-25.141-10.856-37.847-21.744-96.765-24.68-99.837-8.274-10.411-42.777-36.816-63.941-49.03-8.006-4.6205-12.333-7.4865-12.671-9.5179 6.761-6.83 15.111-15.865 22.598-21.606 7.1766-5.5031 13.711-11.709 23.713-15.423 43.963-19.8 69.101 7.6176 75.066 2.0656 0 0-9.458-10.841-5.257-9.0564 4.3021 2.3303 18.323 5.0784 19.862 6.5094 16.023 12.534 57.913 58.344 83.161 106.68 6.0639 11.84 8.5288 19.636 5.7164 33.893-2.8199 14.27-5.0017 22.117-8.0777 31.647-2.7784 6.371-18.498 49.988-18.437 55.848-3.1666 23.932 10.264 53.893 10.264 53.893 0.12703-8.1326-0.5003-12.466 0.23677-18.282l0.90404-10.393s-0.573-2.7644-0.46902-3.86c0.6821-7.1867 2.445-13.229 2.9625-17.345 5.0476-31.255 13.822-53.755 23.775-81.182 2.9578-6.9216 6.8277-10.771 6.6303-16.041 0.16274-9.3518-8.2048-21.904-14.252-34.163-6.1-12.39-13.39-26.202-22.96-40.76-21.82-31.376-40.42-55.925-74.48-71.289-9.53-4.1821-47.03-8.2709-59.98-5.8413-15.71 3.2729-29.22 6.5004-39.99 13.398-16.95 10.854-30.27 27.659-45.89 37.561-34.56-17.282-51.24-30.216-54.35-31.999-20.54-11.006-45.2-23.778-71.73-35.89-12.72-11.862-91.71-40.233-164.04-45.892zm442.08 644.59c-21.3-16.65-39.23-33.79-51.05-51.44-3.8582 20.758-17.864 35.542-28.688 50.083-2.1546 3.4104-3.7078 8.0604 6.9022 22.879 2.8598 3.948 13.207 4.6227 20.192 4.2606-7.1065-5.3719-17.918-11.053-19.66-15.977 12.501 8.5109 24.076 10.957 34.538 9.5863 2.3903-0.26867 5.36-2.8037 7.6553-6.7058 4.6637-10.02 8.3155-12.433 12.005-15.13l8.5018 10.651z" stroke="#000" stroke-width=".11397"/>
  </g>
 </g>
</svg>
 + mediatype: image/svg+xml +name: hive-operator +schema: olm.package +--- +entries: +- name: hive-operator.v0.0.0-dev +name: stable +package: hive-operator +schema: olm.channel +--- +image: quay.io/zncdatadev/hive-operator-bundle:0.0.0-dev +name: hive-operator.v0.0.0-dev +package: hive-operator +properties: +- type: olm.gvk + value: + group: zncdata.dev + kind: HiveMetastore + version: v1alpha1 +- type: olm.package + value: + packageName: hive-operator + version: 0.0.0-dev +- type: olm.csv.metadata + value: + annotations: + alm-examples: |- + [ + { + "apiVersion": "zncdata.dev/v1alpha1", + "kind": "HiveMetastore", + "metadata": { + "labels": { + "app.kubernetes.io/created-by": "hive-operator", + "app.kubernetes.io/instance": "hivemetastore-sample", + "app.kubernetes.io/managed-by": "kustomize", + "app.kubernetes.io/name": "hivemetastore", + "app.kubernetes.io/part-of": "hive-operator" + }, + "name": "hivemetastore-sample" + }, + "spec": { + "metastore": { + "roleGroups": { + "default": { + "config": { + "logging": { + "metastore": { + "console": { + "level": "INFO" + } + } + } + }, + "replicas": 1 + } + } + } + } + } + ] + capabilities: Basic Install + categories: Big Data + createdAt: "2024-08-28T12:23:26Z" + operators.operatorframework.io/builder: operator-sdk-v1.35.0 + operators.operatorframework.io/project_layout: go.kubebuilder.io/v4 + apiServiceDefinitions: {} + crdDescriptions: + owned: + - description: HiveMetastore is the Schema for the hivemetastores API + displayName: Hive Metastore + kind: HiveMetastore + name: hivemetastores.zncdata.dev + version: v1alpha1 + description: hive for operator + displayName: Hive Operator + installModes: + - supported: true + type: OwnNamespace + - supported: true + type: SingleNamespace + - supported: false + type: MultiNamespace + - supported: false + type: AllNamespaces + keywords: + - hive + - metastore + links: + - name: Hive Operator + url: https://github.com/zncdatadev/hive-operator + - name: hive + url: https://hive.apache.org/ + maintainers: + - email: zncdatadev@googlegroups.com + name: ZNCDataDev Team + maturity: stable + minKubeVersion: 1.26.1 + provider: + name: zncdatadev + url: https://github.com/zncdatadev +relatedImages: +- image: docker.io/bitnami/kube-rbac-proxy:0.13.1 + name: "" +- image: quay.io/zncdatadev/hive-operator-bundle:0.0.0-dev + name: "" +- image: quay.io/zncdatadev/hive-operator:0.0.0-dev + name: "" +schema: olm.bundle diff --git a/catalog/secret-operator/index.yaml b/catalog/secret-operator/index.yaml index 6bd270d..d573a3a 100644 --- a/catalog/secret-operator/index.yaml +++ b/catalog/secret-operator/index.yaml @@ -163,7 +163,7 @@ properties: }, "pullPolicy": "IfNotPresent", "repository": "quay.io/zncdatadev/secret-csi-driver", - "tag": "v0.0.1" + "tag": "0.0.0-dev" }, "csiProvisioner": { "logging": { @@ -217,7 +217,7 @@ properties: ] capabilities: Basic Install categories: Big Data - createdAt: "2024-08-28T15:30:36Z" + createdAt: "2024-09-05T10:51:31Z" operators.operatorframework.io/builder: operator-sdk-v1.34.2 operators.operatorframework.io/project_layout: go.kubebuilder.io/v4 apiServiceDefinitions: {} diff --git a/catalog/spark-k8s-operator/index.yaml b/catalog/spark-k8s-operator/index.yaml new file mode 100644 index 0000000..67e96ca --- /dev/null +++ b/catalog/spark-k8s-operator/index.yaml @@ -0,0 +1,298 @@ +--- +defaultChannel: stable +description: | + # spark-k8s-operator + // TODO(user): Add simple overview of use/purpose + + ## Description + // TODO(user): An in-depth paragraph about your project and overview of use + + ## Getting Started + You’ll need a Kubernetes cluster to run against. You can use [KIND](https://sigs.k8s.io/kind) to get a local cluster for testing, or run against a remote cluster. + **Note:** Your controller will automatically use the current context in your kubeconfig file (i.e. whatever cluster `kubectl cluster-info` shows). + + ### Running on the cluster + 1. Install Instances of Custom Resources: + + ```sh + kubectl apply -f config/samples/ + ``` + + 2. Build and push your image to the location specified by `IMG`: + + ```sh + make docker-build docker-push IMG=/spark-k8s-operator:tag + ``` + + 3. Deploy the controller to the cluster with the image specified by `IMG`: + + ```sh + make deploy IMG=/spark-k8s-operator:tag + ``` + + ### Uninstall CRDs + To delete the CRDs from the cluster: + + ```sh + make uninstall + ``` + + ### Undeploy controller + UnDeploy the controller from the cluster: + + ```sh + make undeploy + ``` + + ## Contributing + // TODO(user): Add detailed information on how you would like others to contribute to this project + + ### How it works + This project aims to follow the Kubernetes [Operator pattern](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/). + + It uses [Controllers](https://kubernetes.io/docs/concepts/architecture/controller/), + which provide a reconcile function responsible for synchronizing resources until the desired state is reached on the cluster. + + ### Test It Out + 1. Install the CRDs into the cluster: + + ```sh + make install + ``` + + 2. Run your controller (this will run in the foreground, so switch to a new terminal if you want to leave it running): + + ```sh + make run + ``` + + **NOTE:** You can also run this in one step by running: `make install run` + + ### Modifying the API definitions + If you are editing the API definitions, generate the manifests such as CRs or CRDs using: + + ```sh + make manifests + ``` + + **NOTE:** Run `make --help` for more information on all potential `make` targets + + More information can be found via the [Kubebuilder Documentation](https://book.kubebuilder.io/introduction.html) + + ## License + + Copyright 2023 zncdatadev. + + 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. +icon: + base64data: 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 + mediatype: image/svg+xml +name: spark-k8s-operator +schema: olm.package +--- +entries: +- name: spark-k8s-operator.v0.0.0-dev +name: stable +package: spark-k8s-operator +schema: olm.channel +--- +image: quay.io/zncdatadev/spark-k8s-operator-bundle:0.0.0-dev +name: spark-k8s-operator.v0.0.0-dev +package: spark-k8s-operator +properties: +- type: olm.gvk + value: + group: spark.zncdata.dev + kind: SparkHistoryServer + version: v1alpha1 +- type: olm.package + value: + packageName: spark-k8s-operator + version: 0.0.0-dev +- type: olm.csv.metadata + value: + annotations: + alm-examples: |- + [ + { + "apiVersion": "spark.zncdata.dev/v1alpha1", + "kind": "SparkHistoryServer", + "metadata": { + "labels": { + "app.kubernetes.io/created-by": "spark-k8s-operator", + "app.kubernetes.io/instance": "sparkhistoryserver", + "app.kubernetes.io/managed-by": "kustomize", + "app.kubernetes.io/name": "sparkhistoryserver", + "app.kubernetes.io/part-of": "spark-k8s" + }, + "name": "sparkhistoryserver-sample" + }, + "spec": { + "clusterConfig": { + "ingress": { + "annotations": { + "kubernetes.io/ingress.class": "nginx", + "nginx.ingress.kubernetes.io/rewrite-target": "/" + }, + "enabled": true, + "host": "spark-history.example.com" + } + }, + "clusterOperation": { + "stopped": false + }, + "image": { + "pullPolicy": "IfNotPresent", + "repository": "bitnami/spark", + "tag": "3.1.1" + }, + "sparkHistory": { + "config": { + "eventLog": { + "dir": "/tmp", + "enabled": true, + "mountMode": "pvc" + }, + "resources": { + "cpu": { + "max": "200m", + "min": "100m" + }, + "memory": { + "limit": "512Mi" + } + } + }, + "roleGroups": { + "default": { + "config": { + "gracefulShutdownTimeout": "10s", + "logging": { + "sparkHistory": { + "console": { + "level": "INFO" + } + } + }, + "nodeSelector": { + "app": "default" + }, + "resources": { + "cpu": { + "max": "400m", + "min": "300m" + }, + "memory": { + "limit": "612Mi" + } + } + }, + "podOverride": { + "metadata": { + "labels": { + "foo": "bar" + } + } + }, + "replicas": 1 + } + } + } + } + } + ] + capabilities: Basic Install + categories: Big Data + createdAt: "2024-08-28T12:03:35Z" + operators.operatorframework.io/builder: operator-sdk-v1.35.0 + operators.operatorframework.io/project_layout: go.kubebuilder.io/v4 + apiServiceDefinitions: {} + crdDescriptions: + owned: + - description: SparkHistoryServer is the Schema for the sparkhistoryservers + API + displayName: Spark History Server + kind: SparkHistoryServer + name: sparkhistoryservers.spark.zncdata.dev + resources: + - kind: ConfigMap + name: "" + version: v1 + - kind: Deployment + name: "" + version: app/v1 + - kind: Ingress + name: "" + version: v1 + - kind: PersistentVolume + name: "" + version: v1 + - kind: PersistentVolumeClaim + name: "" + version: v1 + - kind: Pod + name: "" + version: v1 + - kind: PodDisruptionBudget + name: "" + version: v1 + - kind: Service + name: "" + version: v1 + specDescriptors: + - description: spark history server cluster config + displayName: Cluster Config + path: clusterConfig + - displayName: Image + path: image + - description: spark history server role spec + displayName: Spark History + path: sparkHistory + version: v1alpha1 + description: spark for k8s operator + displayName: Spark K8s Operator + installModes: + - supported: true + type: OwnNamespace + - supported: true + type: SingleNamespace + - supported: false + type: MultiNamespace + - supported: true + type: AllNamespaces + keywords: + - spark + - k8s + links: + - name: Spark Website + url: https://spark.apache.org/ + - name: Spark K8s Operator + url: https://github.com/zncdatadev/spark-k8s-operator + - name: spark + url: https://spark.apache.org/ + maintainers: + - email: zncdatadev@googlegroups.com + name: ZNCDataDev Team + maturity: stable + minKubeVersion: 1.26.1 + provider: + name: zncdatadev + url: https://github.com/zncdatadev +relatedImages: +- image: docker.io/bitnami/kube-rbac-proxy:0.13.1 + name: "" +- image: quay.io/zncdatadev/spark-k8s-operator-bundle:0.0.0-dev + name: "" +- image: quay.io/zncdatadev/spark-k8s-operator:0.0.0-dev + name: "" +schema: olm.bundle diff --git a/catalog/superset-operator/index.yaml b/catalog/superset-operator/index.yaml new file mode 100644 index 0000000..5cf6295 --- /dev/null +++ b/catalog/superset-operator/index.yaml @@ -0,0 +1,212 @@ +--- +defaultChannel: stable +description: |+ + # superset-operator + + // TODO(user): Add simple overview of use/purpose + + ## Description + + // TODO(user): An in-depth paragraph about your project and overview of use + + ## Getting Started + + You’ll need a Kubernetes cluster to run against. You can use [KIND](https://sigs.k8s.io/kind) to get a local cluster for testing, or run against a remote cluster. + **Note:** Your controller will automatically use the current context in your kubeconfig file (i.e. whatever cluster `kubectl cluster-info` shows). + + ### Running on the cluster + + 1. Install Instances of Custom Resources: + + ```sh + kubectl apply -f config/samples/ + ``` + + 2. Build and push your image to the location specified by `IMG`: + + ```sh + make docker-build docker-push IMG=/superset-operator:tag + ``` + + 3. Deploy the controller to the cluster with the image specified by `IMG`: + + ```sh + make deploy IMG=/superset-operator:tag + ``` + + ### Uninstall CRDs + + To delete the CRDs from the cluster: + + ```sh + make uninstall + ``` + + ### Undeploy controller + + UnDeploy the controller from the cluster: + + ```sh + make undeploy + ``` + + ## Contributing + + // TODO(user): Add detailed information on how you would like others to contribute to this project + + ### How it works + + This project aims to follow the Kubernetes [Operator pattern](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/). + + It uses [Controllers](https://kubernetes.io/docs/concepts/architecture/controller/), + which provide a reconcile function responsible for synchronizing resources until the desired state is reached on the cluster. + + ### Test It Out + + 1. Install the CRDs into the cluster: + + ```sh + make install + ``` + + 2. Run your controller (this will run in the foreground, so switch to a new terminal if you want to leave it running): + + ```sh + make run + ``` + + **NOTE:** You can also run this in one step by running: `make install run` + + ### Modifying the API definitions + + If you are editing the API definitions, generate the manifests such as CRs or CRDs using: + + ```sh + make manifests + ``` + + **NOTE:** Run `make --help` for more information on all potential `make` targets + + More information can be found via the [Kubebuilder Documentation](https://book.kubebuilder.io/introduction.html) + + ## License + + Copyright 2024 zncdatadev. + + 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. + +icon: + base64data: iVBORw0KGgoAAAANSUhEUgAAAQQAAAEECAYAAADOCEoKAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAyNpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDYuMC1jMDAyIDc5LjE2NDM2MCwgMjAyMC8wMi8xMy0wMTowNzoyMiAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIDIwMjAgTWFjaW50b3NoIiB4bXBNTTpJbnN0YW5jZUlEPSJ4bXAuaWlkOkM3RkZDMENGQjVGQzExRUFCRUJCQzE1QTBBREIwQkQ2IiB4bXBNTTpEb2N1bWVudElEPSJ4bXAuZGlkOkM3RkZDMEQwQjVGQzExRUFCRUJCQzE1QTBBREIwQkQ2Ij4gPHhtcE1NOkRlcml2ZWRGcm9tIHN0UmVmOmluc3RhbmNlSUQ9InhtcC5paWQ6QjQ1MTFFOUFCNEQ3MTFFQUJFQkJDMTVBMEFEQjBCRDYiIHN0UmVmOmRvY3VtZW50SUQ9InhtcC5kaWQ6QzdGRkMwQ0VCNUZDMTFFQUJFQkJDMTVBMEFEQjBCRDYiLz4gPC9yZGY6RGVzY3JpcHRpb24+IDwvcmRmOlJERj4gPC94OnhtcG1ldGE+IDw/eHBhY2tldCBlbmQ9InIiPz4oGrHeAAAm4klEQVR42uydCXhV1bXH152S3MwjISRAQphrRUGqdQIVFcU+RVSsVrTOts7ia/tsbR37nuLYVq2igoqKIjhTFRWQquCAA0KYyQgZCJlzkzu9vfbZsTFmzs3N2Sf/3/etLyEJ9+579tn/s/bea69lCwaDBAAAjB2XAAAAQQAAQBAAABAEAAAEAQAAQQAAQBAAABAEAAAEAQAAQQAAQBAAABAEAAAEAQAAQQAAQBAAABAEAAAEAQAAQQAAQBAAABAEAAAEAQAAQQAAQBAAABAEAAAEAQAAQQAAQBAAABAEAAAEAQAAIAgAAAgCAACCAACAIAAAIAgAAAgCAACCAACAIAAAIAgAAAgCAACCAACAIAAAIAgAAAgCAACCAACAIAAAIAgAAAgCAACCAACAIAAAIAgAAAgCAACCAACAIAAAIAgAAAgCAACCAACAIAAAIAgAAABBAABAEAAAEAQAAAQBAABBAABAEAAAfcB5yimnDJbPmi4sU1iasFRhicJS+BoIixIWqf7OK6xRWK2wSmFlwkqFFQkrERbs11YGgxRwRZIt4Ceb30dks3Vf3X1eakgfSbUjxlP0vt3i//up5LhzicRXR1MDNcenUNAVId+jNc0JqZSUt4FyXv0b+aNiKWi33HMiVthwYVnqPuD+TxLmVv3OF7lJmEeYX/U7W4WyYmF7B4UgWPAzcUf/RNhPhY1WN0KGuhmGCYvoxWv61Q1RKCxffd0s7Eth36nfA3MQJ2ySsMOEjVX9ny1spPpdT/GqvucHwj71daewb4VtElYOQTAPrOwHCztC2LFKBHKFRYf4fRxKUNh+3uZ3fLNsE7ZW2GphG4UdwLgMG+zxTRF2krCjhI0XFh/C13cJG6GsLR4lDluEfSTs30okmiAI4YOf9icKO07YCeoJMNDtYZsm7E/C6oS9L+xfwlYJ24ExG3JyhJ0sbJawGWrKNxBEKW+U7Sz1M55ifqDuAe7/PRCE/nEDzxf2C3UDRJi4rTxfPV0Z866wN4U9B8+hT3CfzxN2pjAzL3wNEXauMlLC8Lbq/zKzX2Szrx5NF7ZYqeyjwk41uRi0B7uyDwvbLexJ5daC7jNR2IPq+j1hcjFoD/Zi71P38IvCToMg9Axe+b1c2BfCPlRPhWQL3NgJwi4Wtk7Yp8J+pdZAQPvwtPANMhZtryNjQVhn+L6e2+oz3WDG+9pMgsDbgL9XT4J/Cpts4Zv9cGHPCtulbowIjP/v4SnBWjXVOs2in5G9nvvVvX4nGdvhEIRW8GIcr9b+lYx94sFCtroxeOFx/iAXAp4K8Er9K8KOGSSfmXdDblH3/j3CYga7IFxExpbd7RaZFvQW3im5l2w2diXPi6iuIFddlRGUZLP8rOIgJQK88Hb0IO1/Do66Wdh2YdcPRkHgfePVwp4WNgZeMsnlBJvfPzGi7sCSisknrK7OnXSUu6yAHJ4GK0YOMnHKO/pWTROAsX39ABkBb8cPFkG4V9jnZOzbA0VQeAJR+4vpwPjDaeeZ103bNeeGdUUnznvE7vcmuytKlGZYxlu4UNhWMtZPwI85lIztyoXhnkaEUxA4wm8T5srtiIHdQe6KIqrJPoh2zb6GoipLhWdQTwUnzrtq86/v3FY19rBfG95Cve7eQraaGixST0PQOZcIyyMjAMtSgsAi8DEZEV2gjRhEVpXJA0a7zrqRAg4nORuqyd7sIRaBhqE5KdvOv+Wp/FmXv2Lz+9Ki9u/VdW3hCjJCfE9Br/cIDpfnwLb/tYIgsLuzXE0TwI+mCXZy1VfL73cKMWhMzRTewT4pEi2Dnv/tFH9TPH3umXkX3b6tduTEuSwULBiaeAscufeasMdo4EKMrcDvhK3pb8+qP+8oXj3mBaPZ6Mt2EIPd4fXIwb7nF1dS1ZgpFFVeZIjBDzwIO9nF37lL86khIzcxb95tLxbO+NVCV0ONg3cjTC4Kpyuv4L/Q4SGBD/B9p75qJQhnCPuKjEMo4MdqQLZAgCIPlFLxcedS6dRTKaqiuNO/ZwGJZG+hqZ4KT/r1JVvPu2WTNzbpUHd50fcCYzIWCHuVBvd2cn+QpDyFS3URBA7PXUHGkWHQ7lRBTAUqCmn/wdOoaMYFFFldTja/t8tBLb2FpkZyl+VT1fip47dceveXVeOmXuQuKxRTiCazeAscos0BRjehp/sVPtfxB7MLAi8ePom+6mxQO8i9v4Rqh0+gXaf/VmYy4t0DsnWzK5RosAj43HG09fw/Pl10wi8fiKgxgpnaTjnCzOHKpT0aPR0W7qYQr8+FUhD+h7B42KUYsDfQHJdEO8+eT4HIaHLVVvbqyc6vFVG9n5wNtVQw85Lrd5w9f5X4aTxPQwbIU2DPkA9tZaKnwwo/hB8O1YuFKh8Cr4Dehb7pbJpgF4O3RuYzlDsKQ4bLp3xfnug88NnD4HWE8skzTvDGp3yb/u9XZ0ZUV2wJ88e7lxBfMpBcI8wn7EYzeAhXUpj2SLVF7ig0UYTwBvJPvZSqxk6lqIqi0DzJeQoR9FN0WT7VjpgwYs8ZV38lhOFY9h5kMtX+X2xcCjEwBRz1eftACwIfT30UfdHVozxIUZV7qeSYObTviNNkiHJoczfbpAcSUVXGgU0RZVNPWVM3fPx5kTVCFAJ+6qe0C5y3kvNVnIMONg18arhPuw99mTJwctM30Addu/XRpflUcdDRYq5/MUXUVJLN19z9RcQeegsuMS3xRcXS3mPnLPHGJWU4mhrv87siQ/1OfDqTY+1xMM188O4DZwZ/L5weAkcgrsG170oMHMShxnVZY2nXmdeRXUwbnI21/SMGrdcqPHXSKyk/7KQFzXEpf5W7GMGQuSQTyIgxgRiYl3eo/SzR/SYInM0mEde9czFgl90XHUc7zr6J/FExwjvYH5ZtQRYFDm3mmAV/pPv3gUj3QyF6aU5zz6ntEGxkbmxqOhcWQbhD2JG45l08pYUnwFODXbOvo8ahOdJTCGuMgM0mqz/Z/V5qjk+91heb+Jidpyq95+dKDNzoYS0YRcap0n4VBL4p/ohr3flAdPiapDeQP/MSqvzJUeqMwgBFEYqpgk2YPyr6ioArcnHLzkPwR9OWThceOXcFn1Z1oYO1gvNOnNVfgsCPt7dxjbsegJHCG9h79Gzad/QZwjMoCeX8vZdtCshdjaDTNU+0ZTHXfLRRmy1JW6disBodqy0vk1HDNOSC8BjWDbpaN7DLIKEDE46Q3oGrppLswlswx8GjoBSmoMM1T0wdHo0p3EqOxnoKOCOkt+BoqBXTC588Z9GKIyAGlmBJqAXhZ9RPp6usIwbGjkLD0GxOgSbn7s7GunZc8wGe0QT95HPHXimmEAtsAZ+sNO2PNJYFbIEf1KydKuwT9Kwl4LJ3s0MpCEtxTTsXAz5cxDsJO865mXyxiWTaXAW8piAGfkNG7k1Bu/MvsYV5FHmgTO5KBP6z6HkQxMByPNOtdYHRo0d39Te/IaOuImj3kcv7/vXyTAGLQXXuIXLaMMCnDrvRbhv5YuKnx+dvLhv12j8+d5cXiMeDaLPdzmXTuYJ1JDrXUnAxII4uXdUXD4EDkO7Dtex4UPHWInsHHIVYedAx5K4o1CK1mc3nlZ7C/oOPfcQbl3RG/J7vePrAyTc2kAkKhoB+4b+pi5J4Xd25XFUGefA6dL9J5jYoPXwWlRxzJkVVlhAFgnq0nbdHueaD+HbLxXetKJ88Y3ZkVRnnPhyCjrU09/ZWEPgp8Ttcv47WDewydXrVuKm057QrKKKuSoYm65YN2RY0MjiJdi8PUvAY9KzlOY+MTM49FoQ/k/nLxQ+QGDhkNuSGISNox1k3yIU6TpZqth2Fzj+EDFYib0w8jX55ASV/+5FMBQ8GBQt6Kgh8CvJ6XLf2PQPOa8BbdTvOmU/NsUmyroLpFxHbzHWCDgc1JQ6hEe8tprSNH1BTyjCy6TLdAX1lbkdTw44E4SpCmGqH827eUdj9X1dT3fDxcg1BLzEw1j48qVk05LN3KPPDpeRJGqoWQiEIg4j5PREEZMxtRwxsfh9FCW+g8MR5VHHIdCMFmm5rBoEAedKyKGHHRsp54xE5ZfBHRg18eDUIN1xJK7K9qUFbOHZ9pIUvxGZhO8koILJL2D5hFcKa1SMyUrlT2WQE6IwjLkEXDCa6ag9QyVGzqXj6ORR5YJ9xRkAjQeBtRk9yhjxsxesGLALemMS2EYpWpJSMGolbVf8XCCsX5lG/Z2+YF1DSyaglMlFYLhmlB626jhZPRv2UpV0JwlUW++Dc6Vwn4gMygjL29OI14pwNtSc0ZOScvPeYM88K2hypAVcU2X1eooAeosCeQXNcMjmaPTTmpQXyNGajmDZYWAxY8N8iI1nIWiX4PYUzSM8gozT7GWoQWYlr2gqCbebMma3/HSus1iIflr0ArhHxtPIC+gTXYKwZNYlKp5wYG7W/5MKm1MyLa0ZOnExi7s31EEwtDMITCES6pSCMefH/KPWrD6kxfaTh4VgPFoFFwpaF+HU5Kcw8Ms70WKloMW9BFne0hjDLAh+wjIxwa07x9ddQiIEcUza7XEMQg6sufvc3/8ha9eyUjI9fnxNTtP0rHmi+mAQ1Dw+aTgyCTqfcURj+7mIhBh9QY1qWFcWAiwrz6czT+kEMmEphD6pp5MVq2mEF5rb+R1tBuFDzD/cPNfd7tH9GppFDwBufIqsmxRRvXz5y5cJDh6967lLhJZQ1ifl50OEim8kGmyc1k9LXv0WZq5dSU9JQPq9gJSFYL4wDquao78MBe518COh+C1y/CzoShAg1V9J1nYDneFcLqwvLU1cMKm98sjzhmLDtiydzlz8wNn39mwvZW2DjOfvArxv45Y5C4tbPKfuNx6QX44+wzI4CL35cq7yCdQPw/l4yduNOVN6DrhwibGh7gsBnpnU84bZX2GRhrw2IO+5wkiclg2xeb3XmmpcvG/XaP+ZG1FbWNqbxepRtwAYfi0FT8lByVxRT7isPGJ6NEASbNaYKXDKOE77+zQRtWaUG1XaNr+fs9gThJA0/SIkSgy0D2Qj2BvzuGGoUrnni1g0vjVv8l4lJeRtWe4QoBMQTOdzegrGjkEK25ibKfeleuaPAawgW2VG4h4zcnltM1KZCdR9u1vSaHtueIOhWsbeBjGrD+0zRGuUJ8Faew9NQlLvsgeMyP3jhIW9skvFkDtdgFB6AT4gTC1HuiocprmALNaZkWkEMuHYhL4CZ9cBdnRKqMg2v7fS2gjBMuT06cZywIrM1igdec3wyeeOSaPh7z1w/avmDVwSdLnlwqN8HpZEzkdOu04h3F1HqN2tkiLJN/zWDAnV/vmTydtaQscCpG7yGMKW1IByh2Qf4AxmJPEwJu+z8hObV/bSN7z8+9rk7ZjmaGuWZgX4VBZtNLiKmf/omDVvzMnmSLXFG4XNhk4R9p0l7twm7RMPrfEhrQZigUcN57mj+atP8tLY5qHHICErY+dXb456744iI+iqPR54qDL0oGGcUeA3jM8p++wnyxiaS36X9jsL7alpYpVm7nyJj4VMnJrUWhMkaNfwCfZpqpD73pA0n977d68ctvvWwqP0l1dKND+FCo3FGYSi5SwsodxlvjVtiR+EVMsKGdf0Q52nW3sNbC8KhmjSaK9p+od2tIQYm70BE7d/73YRFt06OKi8sb0wNjacgdxTiU2Si19FL76WI2gPUlJim+yLiC9TDikMmZLew5zVqL4dju+1qQSFHk0b/j653h3TpUzI5Pfuu8Yv/fJh7f0mdp4+Hi2xyRyGW+KDVqBUPU2zxdgqV0AwgSzV8unbErRq1lVMmZrMgDNOkwbxY87m2t4Ysvio8hZRhHBdQMO7ZOw6PqCpr6vWaAh9YckYYOwrvPE3Jm9YRB0OZIUKyD/Cp1HPJOvABu3UatTeDBUGXLLuP6XxncD1FnjrwU51FIKqiePO4Z2870lVXTU1J6T0XBd5REB7H0E9ep2FrlxGfoyCb1mcU3hV2JlmPxRq1dSTfQaM1aexyXe+IoMq2xGXUjOmDXz7NY/bt+XLs83cey9maeR2gu093Of1IzaSkLZ9Q9luPU3NcEvldkTrvKHBl6ZPJmvAUqFmTto5hQcjWoKF7hOVre0sESeVKsP1gUDemDae4/M0f5b58/xx2/33R8V2KgtxRSMkgd2m+PKPAZynk/9N3R4HPAFg5/TvnF/lWk7bKNQQdcm+/o++6gd/wDNpLniKe6JybIHnLJ8tz3nh0vjc2QaZG72hwG1GQKeTgHYWX7yNnfS01hSMCsv/gU4JHkr5biz3xgHQgRRdB+FrHaYIRhxD4gWfwI9dBzPt5TSH90zfvG/7eMwuaEtLkYmFb91/uKETHyWrNua88RLFF26iJT1nqvaPAYlBB1ucjTdoZr4sglOjoGRAvJFIXadXUEWo+qpz1/pKbh37y+mssED/wKFp2FOKSaeTKhWpHQfusRyeQkfR0MLBTk3bGsiC4NWhosUZqIJ/8XF5dHirqTp5FrqLkiiKvGPDZbz1+RlLe+jwe8N+vJ/COQmomZXz8GmV8tIKaUodpVzKuDZeTkfR2sHBAk3ZGsCDoUJClzFwDvhPsdrL7fMY2Yw8GLU8JvNHx0lvIfeXBadH79jTy4qHd1yy9gaTNnwrv4EmZvs3fzpRCj3mUDOW+R9gT6vuemQoFt6ntW7nW0upr27+3tfxs4OFTkE0a9JCD07CbPUtSI5kgEzQ/rXmw8sIfn2Tk73k+L786XGT3e+VmgsPbLMTA26tqTjLLUUIaufcXl41Zes+0LZfctaFqzBRK2rpBiMT9FBCv6Y2O027dgK+Fq7466GysfTLgcPY6n0FLYdqgw9m+Tgdae2RBKcq8SMv5Lwf4mvE93KDBWHPxlTV7HTLOXecb6Eb4o9wcdiyTlXL1Ji7nxkeauc6BQ9zwUhBsdqNWg1FNuZfC45fRjNGl+Z/lLntwVsFJFy7NfvPxWFdDrfy5jmIQtb+E6kZOqCqbctJljsb63m+RBg1R9kXFSHGQg15cD34P9qQMzyDwfV4IX0w8JWzfSCmb1skQ7wGcZvnUfWz6+a5TA1fGFKLFyUmddVWUWl5I/sho4RU4yVVTKW9QmzzqrG42IQryCdYHV7UlxDkuf/PbP3niv+sCrohYXcWAC+Hy2siu2dcl1GWNfdRZX937QkBqTYW3cW3BlmvlMwShuUkWsLWxIPMirOgvvmZOIaRDvnjXEIQBdMWp/aJIZsPHjTR7FBUvenJvDuiZeDll4MxHccn/ueGV6xpsb67c1/fjNYWY+PfF9GNo0O7UTwyEMHJxG74WO8+6gU972mMLtlwpBi/HHtzS6z5Q27k/EgQxVeNkMKp2hjGdE21wNtaZoRhvFOmxeO+zayAIfAek0eCDa0wcz66vdjsKXCXb2yQrWu2ZdQXxOkhURVHLwOQTq5f3XGG0TvQSp4kg+O2kRzaazEEmBlyq+zd6Nt0mXfvIyr1UPO0cKv35aUIMStq6Uf8U9ovue0va54RM0qSdDSwI5Ro0NGMQiQEf/71X29YL74BrQeyfNJ0KT76QIqvLye5vbs/LeZ26nelbe0HQJd9IDQuCDlVnJg4SMeA03i/o2ni5o1BZQnVZY2jXGVfL4CzeVQh2fCybqzKPHQT9qksS42ruKR3Cgk8eBDcNFxFdp7MY8LasNzqBdp51E/kj3LJATLDzOpLsNqzvcEr4fUCSTfe+1aXmSTH3lg4lqCZYfNrALiVn6dUyw4ncUWiokbEYO+dcT/UZOcJT2Nfd1f1EMlLqJ1u0bzkYaYombd3BN2ChJo093aI3zHBhn5GR007LNQOHj3cUDlD+qZfRgQlHkLu8qCvPoC3D1DWIt2D/clXqKE3aupN7TZfjp1dY8GYZogZCirafQLj0vIuw78jTaa8wjkrs5RbhKDV9iLZYH8/TqK0lLAiciahGg8YeQnoVlOmOZ/ClsHSd1w3cFUVUOfHnlD/zErlmYPM19yVuYjwZiXQTLNLHvDai0/pXIQsChy5/o0mD/88iN8o4YRtJ4/iKljMK9UNzaOecG2QkpbOxNhSJXln0v9BZKFtxm0Zt3SWstKX3vtSk0RzMcpDmN8nRSgxS9BUDu/QG/O5Y2nnOfHmIKKK6PJQhwrlkZMkap7l3oFONR1nioEUQNmnU8MUa3yQsaJxOy63tJxDTAaengRxej4w1qMscIz2FfjgvkC7eayPZuMSYloFJizRr7xetBeFLjRrOdShv0PAGuY6M6DzSWQxsPp/0BgpOupD2//RYY0eh/+pBCOG08XbsHM2uFFeemqFZmze1FYQyjRrPFU2natTeJ4Q9qP2MmHcU9hdT6eGzqOTYsymyct/3R5L79W1t9mXiy580uUpjhC3RrGc5X8MnrQWBfbK1mn2ID4VlmbyNHJbL24qXaq8FvIhYUUxV46bSnlmXk7OuWiaHCdtJTJvtdmEsDGbelozXcBwxnCb+QGtBINInVXQLMWqwmVUUWAS+E3aYJcSgci81Dhkucxvw6UNXQ3VPg49C4CnY5pBNuLZB2zEmXFdgMeCIy6EadvH3IfOte/RVDT8IX3xeHZ1kojZx7oYX1DTBqb8Y2MlVW0kBZyTtnHMjNccmh3pHoaeuQg7ZbWuFOPyxJemqCchR96GuuyJvtScIBWRUWNYN3q/mbbyLTNCW35JRa8AaFYzVjoLTUy93FGpHTpRHm02QgUjcuY47RDs2kM1+9H9mvQMCF6j9Vq0d6EgFtaos1dbnW6LrrSvsaWEvkhECG254O5G3bf5O+iTD6PKSctbiiKoyKppxAVUcerwSA5OcPDROQU4NOF0fCWFYKPQgJ8yFa4aqe+4V0vUcisGKH+hsm18+r/ldPFd5Of9L4Slzf5awNWRsJ04mKyG8A057Vn7YTCo6/pcUeaCUKNCNSlThVYWWtl4SiHRvD7giH7IFg6OMrM795jHw4P+jus8uskBPL+5MEHaQsRCmM+zP/k59loeE/SzEr8+LmPOVR/CysGPJYhg7CkVUm3Mw7f7FFTJzMaecN21uR856bbc7gg7ntf7I6O3+SPeTtiCdwEVzOFt2iNYZOEL2bnVf3UFGnkTd+cF0gWlv0Yvd3kct8GG5w65V9pWw1WRUkWbB68mRb149Hi3seGGzyAg9dpJFkanThTfQlJRO28++SWaWjqgpNce6QReiwLsfAYdDPOScFwvputgfFZMXUVu5Unz/mnBsvqOenezlKQGfqziRjDqUP7Ngdz/a1pWyzZw5s+0fccIKDlJyWfWeJ+OEJyv9bjIyRlWTcciLf8dn1/mcwQgyVo3HkzXP6bcjBkbqdI5GzLvwNqrN/gm5ywvNLwZtZztiytAwZCSlfr2aRq14mPzuGK6uxdWTtqsHAvc/5xL1qD7nJCac6p/zMuSoB8BIC4+BFviz7unKQ+AszLxtNs+iF4H93mxloNWagaPJIwShlnacfSPV5E4id2m+fmLAla/ShlNc/nc06tWH5efyuyK5pgOfHzlYGSB6v60YtLeG0MLduF6DSg1kCDIHHxVPP4fKDjtJRiXqlspQ1sZMHCKmOBU0etn9sngLF9axBQLo4h9zR3s/7EgQeC99La7Z4CAoU6cXUfmhx1HBiRdQZFW5LFirkyLwoPfGJMrvR798H0WVF5EnOUO7ildhgndI1vREEJgbcN0Gw7qBg9z7S6h2xETadca15OQCtp6GUCQ6CeOHCJI/0k2+6HjKef0RStj+JXnSsiAGHTO/o1901ut8AnI1rp21iag7IMRgPG07/xbiGpIcphzuMwp9VAOOWqSm5KGU9eHzlP7ZSvKkZqJjO4a9/zd6IwjMdbh+Fl898PtqxJP1z974ZKPCknYuDlGj8AbSvlxFWe8voabE9D5X37Y4nY7prgSBcy0uwzW0Lk0Jqack5W24fczzd5/PJdR90XFkC+qxCMdTAvYG4nd9Qzmv/p18UTHCoiEGHcM5D97piyAwl+M6WpZTbYHgx57kdEr9es3zI1Y+da03NlGWUjf7oJI7CmKawAVhRr90rywD741Nwo5C53QZSuAYPXp0V3/DwRv1wk7C9bQUc76fS9rs5BdP14QdGzcEnBH26rFTpnHORDm4TBiuLHcUxOBn0Rq35E6KLssnT8owLCJ2zt+oG4cXuyMIDMc7/1JYKq6rJbiQjJOhKk+iVw4m3rePrC5f3ZyQEudJyTrSFvCZrxQ7hyeLaYE3JoFGv3I/JeWtp8YhI7SZ5gwQXND5uO78YU+Wk8/CdbUElwl7pvUA40U4nib4YhOoOSGV4ndvmh9TsuPvAafLZB6C0VYOPspa9SylbvyAPGnDzSda5mNud/+wJ4d0OCsrH/u8E9dXWy6i1sddORVafRUVT59L+w+eJqs3t4iAGGTXOBvrXX53zBWcF4G9iAEXBzHueRExfcNKyvrgBXkAS26RQhA643Fhq/pDEJi7hJ0q7EhcZ83FoMVF9PtkeC9XYPJHRsvFOZ4+GOa7MqKqwifm678NCqEYSFHgdQPO6Zi47XPKfuMRWRyGg5GwiNgpO6mHNVF7E4HCR4C9uNZacQF1UOCGaypw9mQ+5ehsqCFHUwPZvU3Gqn1MEg/Aq1O+XbvA544jFoWBeBrL7cXkofLkZe4yzsBvk2HKEIMumdnT/9AbQeDTkNhx0AfeTXiudyPRJhOMJGz7/OakvPW3+WISwv5U5vdiD4ZFK/fl+yii9oBcQ8COQpdwsZgd4RAEZrWwa3DNTQ8n9lje+zl7UHoFASEC0ft2/yUhb8N1HCbMsQrhGJC8c+BzxxIHTI1a8RDFFWzB9mL34KLIL/TmP/YlaJ0zKz2Ia29KOOELV7b6oM+vJNOTOagpIY0St3/5cM6rf/uVccw4rX8HJm8vOiOoOT6FRrzzNKV+s4YaU7OwgNg1Lwn7fW//c19PsfCJSIQ2m4s9wn5KqppvyLDbpQgk5W1YMub5u493NtQ2y0NEcoD2wyAV0xV+/aGfvEHD1r5CjcIzIHnoCoLQCRwvNLdP3RyCRpxNXcRHg7DBseqcEagw5K+snsx8rDi2aNuH45678+Dovbv2cBwA2RwhfXLzuoFHeANJW9bTyJVPUHNckiwUA++gUzhv6LQ+636IGsOrme+hTwYUnjPydnBtv76LGJSelAzOSrR1/DO3TUr74r21jWmZxpZlCBYb5Y6C8Aai9+2WOwpBITac5wCRiJ3ChxAPJ6NoqykEgeGdhzfRNwMCB4ydF64344EvjxlTsGb0sgXTRr795KN8SrI5IaVPoiB3FOJT5fYnH1jirxw5iUXETllPRkbokJxdD3UmDK5gtAR9FDZ4pJxBRsBYWOFByrsNPGCzPnzhN2Ofv/sqzrTUOCTrB1OMbr8e7yhEx1LA5aJRyx+kmJKd0hOBGHQKRyAeQUbGcDKjIDC/EvYA+qrfyVPrBa8NVAP4ic5nIBqGjOBDRo9NXPj7oxLzNuRzRGGP4hU4BZp4nea4FBLeBqVs+VQmPUHgUadwbMmJoX7R/sqVdaOwK9Fn/cazZFQS2jzgLVGeAA/giJrKj8c9d9eEEe8set7vjiXOsyB/36m3EDR2MIQ3MGzdcsr49wryJGWYt0qUObiVjOhT0kUQmH8KO4aMQiggNHDI+CVkJLowlS9trCukimlEQmPW+0vOH7f4tsti9u5uakwfKQOLOnra80lFji9I+fYjGrHyKRl34HdFYEehfeqEzaYOUqibXRCYdWSUw3oNfdlnOC3+RGFPmbWBcgohBn9j2ghK2P3NwgmL/jQu88MX/8ULjuwttC3C2rKjEFuYR6OWPySmHxHEZyawo9AuH6mx9Gp/vkk40uvWkLHw9Tv0aZ9cRN5j3mH6lqpApcbUYRRwOPOz3378lLFL7rw+uqzQ05Ce/f32JItBc2IaOeuqafSy+8jhaZTeARYR24WrmXNR4aL+fqNw5tu+h4wIOhSA6T4c23Fwf7qI/ektcFo2rrGYsH3jQxOeumV81qrnlnIYtEeIhTc2WWoHi0F0aQF2FNrnGzXt/kO43jDcCfg3qSfdVcIOoL87pFTYr8mI7fhW20/REt2YmsmJTPJHvLvo3AmLbj0lMW/Dxua4RBq58klK3PqZ8CYyIQY/pFmJwCQ17SarCkILjwnLJWuUnQ81C9S1WWSVD8SDnb0Fzn3oLiv4V+7yhyZPXPiHq5K3fFogz0NgR6E1HMczRk0Tws5AluhhD+E3yiVejvuAlpKxaHQzGVmurYXafuRTk5xjIa5g82MBp2tM0OG8Q/wc3qIxPeTpAcfxFAxUI8xQs4tdYk7iMZ2Mo5uDDT4terSwc8kINrI0vIPAiVI5jXrQ7mgWYsALppz6m79WDML+f1vYaWp6uG6gG2OmIn5cjZaPbh4ibCEZZ/qtCh9C4ZRmU8g4LfrvQf505DThvHCao7zGTRb/vBxq3HIYjVMSvmWWhpmxqufXZKQKzyYj4nG9hW6E7cJuVzf+RWQU1AX/gQNveF2Jd6NOVdMoK+Xv/Fp5Qnxv82G0T8zWQKeJLx7nbnxAGSspF4o5hYwFN92eBm+oqcFSjPlus1IZl3KepwTiaA0/R7H6HNz3q8zeWKcmF/VjZQxXoOGtSz5ZOdmk7eVgrH+RkTiG54j7ML77NKD+qowXoGeoB8N0E9+/m9VDgKfB71EI8hRAEDrmQ2V/Ua7XoWQsyPB8nBenkgagTbwYtoWMoKv31VSgGmM55HyjjHOxD1UPhBnKgxwnLHEA2sT9vIuMjEXvkpG6boeuF9ip+Q2yR9kK9e9oNf88VInDSGXD1Q3UV+pV5/N75pOxK7CBjJ0SD8ZrWNmnvK+31b9jyAjk4QfD2FZ9P0pYbAjer4yM0OF8ZXwfbFTrArVWuahOi90kDWQsQrZeiHQJyxDGmTtGCEtRN0i8MLf6vVN9ZThkjheyGtXr1ainwF51I+wmK8YJ6E99m6lli0i0CMMw5UHEqQcH932EMAdx5Rejz9m1b1bizv3Oi5y8A1KojO+BJitfRFsQx0wBAAo7LgEAAIIAAIAgAAAgCAAACAIAAIIAAIAgAAAgCAAACAIAAIIAAIAgAAAgCAAACAIAAIIAAIAgAAAgCAAACAIAAIIAAIAgAAAgCAAACAIAAIIAAIAgAAAgCAAACAIAAIIAAIAgAAAgCAAACAIAAEAQAAAQBAAABAEAAEEAAEAQAAAQBAAABAEAAEEAAEAQAAAQBAAABAEAAEEAAEAQAAAQBAAABAEAAEEAAEAQAAAQBAAABAEAAEEAAEAQAAAQBAAABAEAAEEAAEAQAAAQBAAABAEAAEEAAEAQAAAAggAAgCAAACAIAAAIAgAAggAAgCAAAPrA/wswADs6spEFp/ApAAAAAElFTkSuQmCC + mediatype: image/png +name: superset-operator +schema: olm.package +--- +entries: +- name: superset-operator.v0.0.0-dev +name: stable +package: superset-operator +schema: olm.channel +--- +image: quay.io/zncdatadev/superset-operator-bundle:0.0.0-dev +name: superset-operator.v0.0.0-dev +package: superset-operator +properties: +- type: olm.gvk + value: + group: superset.zncdata.dev + kind: SupersetCluster + version: v1alpha1 +- type: olm.package + value: + packageName: superset-operator + version: 0.0.0-dev +- type: olm.csv.metadata + value: + annotations: + alm-examples: |- + [ + { + "apiVersion": "superset.zncdata.dev/v1alpha1", + "kind": "SupersetCluster", + "metadata": { + "labels": { + "app.kubernetes.io/created-by": "superset-operator", + "app.kubernetes.io/instance": "supersetcluster-sample", + "app.kubernetes.io/managed-by": "kustomize", + "app.kubernetes.io/name": "supersetcluster", + "app.kubernetes.io/part-of": "superset-operator" + }, + "name": "supersetcluster-sample" + }, + "spec": { + "clusterConfig": { + "credentialsSecret": "superset-credentials" + }, + "node": { + "roleGroups": { + "default": { + "replicas": 1 + } + } + } + } + } + ] + capabilities: Basic Install + categories: Big Data + createdAt: "2024-08-30T10:41:15Z" + operators.operatorframework.io/builder: operator-sdk-v1.35.0 + operators.operatorframework.io/project_layout: go.kubebuilder.io/v4 + apiServiceDefinitions: {} + crdDescriptions: + owned: + - description: SupersetCluster is the Schema for the supersetclusters API + displayName: Superset Cluster + kind: SupersetCluster + name: supersetclusters.superset.zncdata.dev + version: v1alpha1 + description: Superset Operator + displayName: Superset Operator + installModes: + - supported: true + type: OwnNamespace + - supported: true + type: SingleNamespace + - supported: false + type: MultiNamespace + - supported: true + type: AllNamespaces + keywords: + - superset + - operator + links: + - name: Superset Operator + url: https://github.com/zncdatadev/superset-operator + - name: Apache Superset + url: https://superset.apache.org/ + maintainers: + - email: zncdatadev@googlegroups.com + name: ZNCDataDev Team + maturity: stable + minKubeVersion: 1.26.1 + provider: + name: zncdatadev + url: https://github.com/zncdatadev/superset-operator +relatedImages: +- image: gcr.io/kubebuilder/kube-rbac-proxy:v0.13.1 + name: "" +- image: quay.io/zncdatadev/superset-operator-bundle:0.0.0-dev + name: "" +- image: quay.io/zncdatadev/superset-operator:0.0.0-dev + name: "" +schema: olm.bundle diff --git a/catalog/zookeeper-operator/index.yaml b/catalog/zookeeper-operator/index.yaml index c94120b..581d0a9 100644 --- a/catalog/zookeeper-operator/index.yaml +++ b/catalog/zookeeper-operator/index.yaml @@ -147,10 +147,6 @@ properties: "clusterConfig": { "listenerClass": "external-unstable" }, - "image": { - "repository": "docker.io/bitnami/zookeeper", - "tag": "3.9.1-debian-12-r15" - }, "server": { "config": { "resources": { @@ -219,7 +215,7 @@ properties: ] capabilities: Basic Install categories: Big Data - createdAt: "2024-08-29T12:14:51Z" + createdAt: "2024-09-06T07:15:55Z" operators.operatorframework.io/builder: operator-sdk-v1.34.2 operators.operatorframework.io/project_layout: go.kubebuilder.io/v4 apiServiceDefinitions: {}