fix: improve kubeClientQPS type consistency in operator chart (#1485)

* fix: improve kubeClientQPS type consistency in operator chart

  - Use explicit float comparison (0.0) in deployment template
  - Update values.yaml kubeClientQPS default from 0 to 0.0 for type consistency
  - Ensures proper float64 type handling in Helm template condition

Signed-off-by: yangw <wuyangmuc@gmail.com>

* update docs

Signed-off-by: yangw <wuyangmuc@gmail.com>

* remove condition

Signed-off-by: yangw <wuyangmuc@gmail.com>

* update test config

Signed-off-by: yangw <wuyangmuc@gmail.com>

* fix lint

Signed-off-by: yangw <wuyangmuc@gmail.com>

---------

Signed-off-by: yangw <wuyangmuc@gmail.com>

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: shubham-cmyk drivebyer

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,5 +1,5 @@
 <!--
-    Please read https://github.com/OT-CONTAINER-KIT/redis-operator/blob/master/CONTRIBUTING.md before submitting
+    Please read https://github.com/OT-CONTAINER-KIT/redis-operator/blob/main/CONTRIBUTING.md before submitting
     your pull request. Please fill in each section below to help us better prioritize your pull request. Thanks!
 -->
 

.github/cherry-pick-bot.yml

@@ -0,0 +1,2 @@
+enabled: true
+preservePullRequestTitle: true

.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: gomod
+    directory: /
+    schedule:
+      interval: monthly
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: monthly

.github/workflows/auto-rebase.yaml

@@ -0,0 +1,31 @@
+name: Automatic Rebase
+
+on:
+  issue_comment:
+    types: [created]
+
+jobs:
+  rebase:
+    name: Rebase
+    if: >-
+      github.event.issue.pull_request != '' && 
+      (
+        contains(github.event.comment.body, '/rebase') || 
+        contains(github.event.comment.body, '/autosquash')
+      )
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      - name: Checkout the latest code
+        uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          fetch-depth: 0
+      - name: Automatic Rebase
+        uses: cirrus-actions/rebase@1.8
+        with:
+          autosquash: ${{ contains(github.event.comment.body, '/autosquash') || contains(github.event.comment.body, '/rebase-autosquash') }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} 

.github/workflows/auto-release.yaml

@@ -0,0 +1,78 @@
+name: Auto Create Release On Tag
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: write
+
+jobs:
+  create-release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Configure Git
+        run: |
+          git config --global user.name "github-actions"
+          git config --global user.email "github-actions@github.com"
+
+      - name: Get version
+        id: get_version
+        run: |
+          echo "VERSION=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
+          echo "TAG=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
+
+      - name: Check if release exists
+        id: check_release
+        run: |
+          RELEASE_EXISTS=$(gh release view ${{ steps.get_version.outputs.VERSION }} --json id 2>/dev/null | jq -r '.id' || echo "")
+          if [ -n "$RELEASE_EXISTS" ] && [ "$RELEASE_EXISTS" != "null" ]; then
+            echo "Release already exists, skipping creation"
+            echo "exists=true" >> $GITHUB_OUTPUT
+          else
+            echo "Release does not exist, will create it"
+            echo "exists=false" >> $GITHUB_OUTPUT
+          fi
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Create release notes
+        id: release_notes
+        if: steps.check_release.outputs.exists == 'false'
+        run: |
+          PREVIOUS_TAG=$(git describe --tags --abbrev=0 ${{ steps.get_version.outputs.VERSION }}^ 2>/dev/null || git rev-list --max-parents=0 HEAD)
+          
+          CHANGELOG=""
+          while IFS= read -r line; do
+            commit_hash=$(echo "$line" | cut -d' ' -f1)
+            commit_msg=$(echo "$line" | cut -d' ' -f2-)
+            author_login=$(gh api repos/${{ github.repository }}/commits/$commit_hash --jq '.author.login' 2>/dev/null || echo "unknown")
+            if [ "$author_login" != "null" ] && [ "$author_login" != "unknown" ]; then
+              CHANGELOG="$CHANGELOG* $commit_msg (@$author_login)"$'\n'
+            else
+              author_name=$(git show --pretty=format:"%an" -s $commit_hash)
+              CHANGELOG="$CHANGELOG* $commit_msg (@$author_name)"$'\n'
+            fi
+          done < <(git log --pretty=format:"%H %s" ${PREVIOUS_TAG}..${{ steps.get_version.outputs.VERSION }})
+          
+          cat > release_notes.md << EOF
+          ## Changes
+          ${CHANGELOG}
+          EOF
+      
+      - name: Create GitHub Release
+        if: steps.check_release.outputs.exists == 'false'
+        uses: softprops/action-gh-release@v2
+        with:
+          name: Release ${{ steps.get_version.outputs.VERSION }}
+          body_path: release_notes.md
+          draft: true
+          prerelease: false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/call-test-charts.yaml

@@ -0,0 +1,46 @@
+name: Test Helm Charts
+
+on:
+  workflow_call:
+    inputs:
+      chart_dirs:
+        description: 'JSON array of chart directories to test'
+        required: false
+        type: string
+        default: '["redis-operator", "redis", "redis-cluster", "redis-replication", "redis-sentinel"]'
+
+jobs:
+  test-charts:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+
+      - name: Create k8s Kind Cluster
+        uses: helm/kind-action@v1.12.0
+        with:
+          cluster_name: kind
+
+      - name: Install Helm
+        uses: azure/setup-helm@v4
+        with:
+          version: v3.5.4
+
+      - name: Install yq
+        run: |
+          sudo snap install yq
+
+      - name: Install and test Redis Related Helm charts
+        run: |
+          kubectl cluster-info --context kind-kind
+          chart_dirs_json='${{ inputs.chart_dirs }}'
+          chart_dirs=($(echo $chart_dirs_json | jq -r '.[]'))
+          for dir in "${chart_dirs[@]}"
+          do
+            if [[ -f ./charts/$dir/Chart.yaml ]]; then
+              helm dependency update ./charts/$dir/
+            fi
+            helm install $dir ./charts/$dir/
+            helm test $dir
+          done
+          echo "Listing installed Helm charts..."

.github/workflows/ci.yaml

@@ -0,0 +1,282 @@
+name: CI
+on:
+  pull_request:
+    branches:
+      - main
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+
+env:
+  GOLANG_VERSION: 1.23.4
+  APPLICATION_NAME: redis-operator
+  DockerImagName: docker.io/opstree/redis-operator
+  BuildDocs: true
+  AppVersion: "v0.15.2"
+  DOCKERFILE_PATH: "**/Dockerfile"
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ env.GOLANG_VERSION }}
+          cache: false
+
+      - name: Get golangci-lint version from Makefile
+        run: |
+          GOLANGCI_VERSION=$(grep '^GOLANGCI_LINT_VERSION' Makefile | cut -d'=' -f2 | tr -d ' ?')
+          echo "GOLANGCI_LINT_VERSION=$GOLANGCI_VERSION" >> $GITHUB_ENV
+
+      - name: Run GolangCI-Lint
+        uses: golangci/golangci-lint-action@v8
+        with:
+          version: ${{ env.GOLANGCI_LINT_VERSION }}
+
+  gotest:
+    needs:
+      - lint
+    name: Go Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ env.GOLANG_VERSION }}
+      - name: Install integration test dependencies
+        run: make integration-test-setup
+      - name: Run Go Tests with coverage
+        run: go test ./... -coverprofile=coverage.txt -covermode=atomic
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          file: ./coverage.txt
+          fail_ci_if_error: false
+          verbose: true
+
+  helm_docs_test:
+    needs: [lint]
+    name: Helm Docs Test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+
+      - name: Ensure documentation is updated
+        uses: docker://jnorwood/helm-docs:latest
+
+      - name: Check for changes
+        run: |
+          if git diff --exit-code; then
+            echo -e "\n####### Helm docs are up-to-date! #######\n"
+          else
+            git status
+            echo -e "\n####### Helm docs are not up-to-date! Please run generate helm docs locally and push the changes #######\n"
+            exit 1
+          fi
+
+  validate_examples:
+    needs: [gotest, helm_docs_test]
+    name: Validate Examples
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install yamllint
+        run: sudo apt-get install -y yamllint
+
+      - name: Lint YAML files
+        run: yamllint --strict ./example
+
+      - name: Install kubectl
+        run: |
+          curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
+          chmod +x kubectl
+          sudo mv kubectl /usr/local/bin/
+
+      - name: Create k8s Kind Cluster
+        uses: helm/kind-action@v1.12.0
+        with:
+          cluster_name: kind
+
+      - name: Apply CRD
+        run: |
+          for crd in $(find ./config/crd/bases -type f -name '*.yaml'); do
+            kubectl create -f $crd
+          done
+
+      - name: Validate CRD Installation
+        run: |
+          CRDs=("redis" "redissentinels" "redisclusters" "redisreplications")
+          for crd in "${CRDs[@]}"; do
+            kubectl get crd $crd.redis.redis.opstreelabs.in || exit 1
+          done
+
+      - name: Validate CR
+        run: |
+          for example in $(find ./example -type f -name '*.yaml'); do
+            kubectl apply --dry-run=server -f $example
+          done
+
+  validate_yaml:
+    needs: [validate_examples]
+    name: Validate YAML
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Install yamllint
+        run: sudo apt-get install -y yamllint
+      - name: Lint YAML files
+        run: yamllint --strict ./tests/
+
+  container_quality_dockerfile_lint:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Execute dockerlinter
+        uses: hadolint/hadolint-action@v3.1.0
+        with:
+          dockerfile: Dockerfile
+          ignore: DL3007,DL3018
+
+  build_go_binary:
+    needs: [lint]
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        arch: ["amd64", "arm64"]
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+      - name: Setup Go Environment
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ env.GOLANG_VERSION }}
+      - name: Set GOARCH
+        run: echo "GOARCH=${{ matrix.arch }}" >> $GITHUB_ENV
+      - name: Build Go Binary
+        run: go build -o ${{ github.workspace }}/${{ env.APPLICATION_NAME }} cmd/main.go
+      - name: Archive Binary
+        run: |
+          mkdir -p ${{ github.workspace }}/compiled/${{ matrix.arch }}
+          zip ${{ github.workspace }}/compiled/${{ matrix.arch }}/${{ env.APPLICATION_NAME }}-${{ matrix.arch }}.zip ${{ github.workspace }}/${{ env.APPLICATION_NAME }}
+
+  build_scan_container_image:
+    needs: [container_quality_dockerfile_lint]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build multi-arch image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          platforms: linux/arm64,linux/amd64
+          push: false
+          tags: ${{ env.DockerImagName }}:latest
+
+  gosec_scan:
+    needs: [build_go_binary]
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+      - name: Gosec Scan
+        uses: securego/gosec@master
+        with:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+          GOSEC_OUTPUT: "junit-xml:/github/workspace/gosec-results.xml"
+
+  helm_chart_test:
+    needs: [gotest]
+    name: Helm Chart Test
+    uses: ./.github/workflows/call-test-charts.yaml
+
+  e2e_test:
+    # DEBUG
+    needs: [validate_yaml, helm_chart_test]
+    name: E2E Test
+    runs-on: ubuntu-latest
+    if: always() && (needs.validate_yaml.result == 'success') && (needs.helm_chart_test.result == 'success' || needs.helm_chart_test.result == 'skipped')
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Build Dockerfile
+        run: docker build . --file Dockerfile --tag redis-operator:e2e
+      - name: Install Cosign
+        uses: sigstore/cosign-installer@v3.9.2
+      - name: Install chainsaw
+        uses: kyverno/action-install-chainsaw@v0.2.12
+        with:
+          verify: true
+      - name: Check install
+        run: chainsaw version
+      - name: Install kubectl
+        run: |
+          curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
+          chmod +x kubectl
+          sudo mv kubectl /usr/local/bin/
+
+      - name: Create k8s Kind Cluster
+        uses: helm/kind-action@v1.12.0
+        with:
+          config: tests/_config/kind-config.yaml
+          cluster_name: kind
+
+      # NOTE: This is a workaround for the issue where the default storage class does not support volume expansion.
+      # Since we don't require PVC resizing (unlike physical disks), we can simply ensure that the requested PVC size is met.
+      - name: Setup k8s Kind Cluster
+        run: |
+          DEFAULT_SC=$(kubectl get storageclass -o=jsonpath='{.items[?(@.metadata.annotations.storageclass\.kubernetes\.io/is-default-class=="true")].metadata.name}')
+          kubectl patch storageclass $DEFAULT_SC -p '{"allowVolumeExpansion": true}'          
+
+          # install cert-manager
+          kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.18.2/cert-manager.yaml
+
+      - name: Load Docker image into Kind
+        run: |
+          kubectl cluster-info --context kind-kind
+          kind load docker-image redis-operator:e2e --name kind
+
+      - name: Install Redis Operator
+        run: |
+          make deploy IMG=redis-operator:e2e
+          kubectl set env deployment/redis-operator-redis-operator -n redis-operator-system OPERATOR_IMAGE=redis-operator:e2e FEATURE_GATES=GenerateConfigInInitContainer=true
+
+      - name: Wait for Redis Operator to be ready
+        run: |
+          kubectl wait --for=condition=available --timeout=300s deployment/redis-operator-redis-operator -n redis-operator-system
+
+      # - name: DEBUG:Install k9s
+      #   run: |
+      #     curl -sS https://webi.sh/k9s | sh; \
+      #     source ~/.config/envman/PATH.env
+
+      # - name: DEBUG:Setup tmate session
+      #   uses: mxschmitt/action-tmate@v3
+      #   with:
+      #     timeout-minutes: 15
+      #     limit-access-to-actor: true
+      #     detached: true
+
+      - name: Run chainsaw test
+        run: chainsaw test --test-dir ./tests/e2e-chainsaw/v1beta2 --config tests/_config/chainsaw-configuration.yaml

.github/workflows/codeql-analysis.yml

@@ -13,10 +13,10 @@ name: "CodeQL"
 
 on:
   push:
-    branches: [ master ]
+    branches: [ main ]
   pull_request:
     # The branches below must be a subset of the branches above
-    branches: [ master ]
+    branches: [ main ]
   schedule:
     - cron: '24 4 * * 5'
 
@@ -39,11 +39,11 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
+      uses: github/codeql-action/init@v3
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -54,7 +54,7 @@ jobs:
     # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
     # If this step fails, then you should remove it and run the build manually (see below)
     - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
+      uses: github/codeql-action/autobuild@v3
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 https://git.io/JvXDl
@@ -68,4 +68,4 @@ jobs:
     #   make release
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
+      uses: github/codeql-action/analyze@v3

.github/workflows/operator-ci.yaml

@@ -1,128 +0,0 @@
-name: CI
-on:
-  pull_request:
-    branches:
-      - master
-  push:
-    branches:
-      - master
-
-env:
-  GolangVersion: 1.17
-  ApplicationName: redis-operator
-  DockerImagName: docker.io/opstree/redis-operator
-  BuildDocs: true
-  AppVersion: "v0.15.0"
-  DOCKERFILE_PATH: '**/Dockerfile'
-
-jobs:
-  gofmt:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: ${{ env.GolangVersion }}
-      - name: Check Go Fmt
-        run: |
-          gofmt_files=$(go fmt ./... | wc -l)
-          if [[ ${gofmt_files} > 0 ]]
-          then
-              echo "Please format golang files using:- go fmt ./..."
-              exit 1
-          else
-              echo "All files are formated using gofmt"
-          fi
-  govet:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: ${{ env.GolangVersion }}
-      - name: Run Go Vet
-        run: go vet ./...
-
-  code_quality_golang_ci_lint:
-    needs: [gofmt, govet]
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: ${{ env.GolangVersion }}
-      - name: Install GolangCI-Lint
-        run: |
-          curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s v1.40.0
-      - name: Run GolangCI-Lint
-        run: ./bin/golangci-lint run --timeout 5m0s ./...
-
-  container_quality_dockerfile_lint:
-    needs: [gofmt, govet]
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-
-      - name: Execute dockerlinter
-        uses: hadolint/hadolint-action@v3.1.0
-        with:
-          dockerfile: Dockerfile
-          ignore: DL3007,DL3018
-
-  build_go_binary:
-    needs: [code_quality_golang_ci_lint]
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        arch: ['amd64', 'arm64']
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v2
-      - name: Setup Go Environment
-        uses: actions/setup-go@v2
-        with:
-          go-version: ${{ env.GOLANG_VERSION }}
-      - name: Set GOARCH
-        run: echo "GOARCH=${{ matrix.arch }}" >> $GITHUB_ENV
-      - name: Build Go Binary
-        run: go build -o ${{ github.workspace }}/${{ env.APPLICATION_NAME }}
-      - name: Archive Binary
-        run: |
-          mkdir -p ${{ github.workspace }}/compiled/${{ matrix.arch }}
-          zip ${{ github.workspace }}/compiled/${{ matrix.arch }}/${{ env.APPLICATION_NAME }}-${{ matrix.arch }}.zip ${{ github.workspace }}/${{ env.APPLICATION_NAME }}
-  build_scan_container_image:
-    needs: [container_quality_dockerfile_lint]
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v2
-
-    - name: Build multi-arch image
-      uses: docker/build-push-action@v2
-      with:
-        context: .
-        platforms: linux/arm64,linux/amd64
-        push: false
-        tags: ${{ env.DockerImagName }}:latest
-
-  gosec_scan:
-    needs: [build_go_binary]
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v2
-      - name: Gosec Scan
-        uses: securego/gosec@master
-        with:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-          GOSEC_OUTPUT: "junit-xml:/github/workspace/gosec-results.xml"
-          

.github/workflows/pr-semantics.yaml

@@ -0,0 +1,83 @@
+# feat: (new feature for the user, not a new feature for build script)
+# fix: (bug fix for the user, not a fix to a build script)
+# build: (changes that affect the build system or external dependencies)
+# chore: (updating grunt tasks etc; no production code change)
+# ci: (updates to CI configuration files and scripts; no production code change)
+# docs: (changes to the documentation)
+# perf: (a code change that improves performance)
+# refactor: (refactoring production code, eg. renaming a variable)
+# style: (formatting, missing semi colons, etc; no production code change)
+# test: (adding missing tests, refactoring tests; no production code change)
+# revert: (reverting a previous commit)
+
+# Example:
+# test(runner): Add test for the runner
+# ^    ^        ^
+# |    |        |__ Subject
+# |    |_______ Scope
+# |____________ Type
+
+name: Semantic PR Validation
+on:
+  pull_request:
+    types:
+      - opened
+      - edited
+      - synchronize
+defaults:
+  run:
+    shell: bash
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Validate Pull Request
+        uses: amannn/action-semantic-pull-request@0723387faaf9b38adef4775cd42cfd5155ed6017
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          # Configure which types are allowed.
+          # Default: https://github.com/commitizen/conventional-commit-types
+          types: |
+            feat
+            fix
+            build
+            chore
+            ci
+            docs
+            perf
+            refactor
+            revert
+            style
+            test
+            revert
+          # Configure which scopes are allowed.
+          scopes: |
+            api
+            deps
+            config
+            client
+            config
+            data
+            test
+            utils
+            docs
+            release
+            testdata
+            standalone
+            replication
+            sentinel
+            cluster
+          ignoreLabels: |
+            bot
+            ignore-semantic-pull-request
+          # Configure that a scope must always be provided.
+          requireScope: false
+          # When using "Squash and merge" on a PR with only one commit, GitHub
+          # will suggest using that commit message instead of the PR title for the
+          # merge commit, and it's easy to commit this by mistake. Enable this option
+          # to also validate the commit message for one commit PRs.
+          validateSingleCommit: true
+          # Related to `validateSingleCommit` you can opt-in to validate that the PR
+          # title matches a single commit to avoid confusion.
+          validateSingleCommitMatchesPrTitle: true

.github/workflows/publish-charts.yaml

@@ -0,0 +1,158 @@
+name: Release Charts
+
+on:
+  push:
+    paths:
+      - 'charts/**'
+      - '.github/workflows/publish-charts.yaml'
+    branches:
+      - main
+
+jobs:
+  lint-charts:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Install Helm
+        uses: azure/setup-helm@v4
+        with:
+          version: v3.5.4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.9'
+          check-latest: true
+
+      - name: Set up chart-testing
+        uses: helm/chart-testing-action@v2.7.0
+
+      - name: Run chart-testing (lint)
+        run: |
+          ct lint --config ct.yaml
+
+  test-charts:
+    needs:
+      - lint-charts
+    uses: ./.github/workflows/call-test-charts.yaml
+
+  release-charts:
+    runs-on: ubuntu-latest
+    needs:
+      - test-charts
+    permissions:
+      packages: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          repository: "${{ github.repository_owner }}/redis-operator"
+          path: "redis-operator"
+          fetch-depth: 0
+
+      - name: Checkout helm-charts
+        uses: actions/checkout@v4
+        with:
+          repository: "${{ github.repository_owner }}/helm-charts"
+          # use token for helm-charts repo
+          token: "${{ secrets.HELM_CHARTER_TOKEN }}"
+          path: "helm-charts"
+          fetch-depth: 0
+
+      - name: Get chart version
+        run: |
+          echo "chart_version=$(echo ${GITHUB_REF##*/v})" >> $GITHUB_ENV
+
+      - name: Install Helm
+        uses: azure/setup-helm@v4
+
+      - name: Make charts
+        shell: bash
+        working-directory: redis-operator
+        run: |
+          helm repo add jetstack https://charts.jetstack.io
+          helm repo update
+
+          chart_dirs=("redis-operator" "redis" "redis-cluster" "redis-replication" "redis-sentinel")
+          for dir in "${chart_dirs[@]}"
+          do
+            if [[ -f ./charts/$dir/Chart.yaml ]]; then
+              helm dependency update ./charts/$dir/
+            fi
+            helm package charts/$dir -d .cr-release-packages
+          done
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3.3.0
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Publish to OCI registry (ghcr.io)
+        shell: bash
+        working-directory: redis-operator
+        run: |
+          shopt -s nullglob
+          for pkg in .cr-release-packages/*; do
+            if [ -z "${pkg:-}" ]; then
+              break
+            fi
+            helm push "${pkg}" "oci://ghcr.io/ot-container-kit/charts"
+          done
+
+      - name: Install chart-releaser
+        uses: helm/chart-releaser-action@v1.7.0
+        with:
+          install_only: true
+
+      # upload charts to helm-charts repos's release
+      - name: Upload charts
+        shell: bash
+        working-directory: redis-operator
+        run: |
+          cr upload
+        env:
+          # GitHub repository
+          CR_GIT_REPO: "helm-charts"
+          # Path to directory with chart packages (default ".cr-release-packages")
+          CR_PACKAGE_PATH: ".cr-release-packages"
+          # use token for helm-charts repo
+          CR_TOKEN: "${{ secrets.HELM_CHARTER_TOKEN }}"
+          # owner
+          CR_OWNER: "${{ github.repository_owner }}"
+          # skip existing charts
+          CR_SKIP_EXISTING: "true"
+
+      # copy artifacts to helm-charts repo, we need those for update index
+      - name: Copy artifacts
+        run: |
+          cp -r redis-operator/.cr-release-packages helm-charts/
+
+      - name: Configure Git
+        working-directory: helm-charts
+        run: |
+          git config user.name "$GITHUB_ACTOR"
+          git config user.email "$GITHUB_ACTOR@users.noreply.github.com"
+
+      # this step will directly push to the main branch, so make sure you have the right permissions
+      - name: Update index
+        working-directory: helm-charts
+        run: |
+          cr index --push
+        env:
+          # GitHub repository
+          CR_GIT_REPO: "helm-charts"
+          # The GitHub pages branch (default "gh-pages")
+          CR_PAGES_BRANCH: "gh-pages"
+          # Path to directory with chart packages (default ".cr-release-packages")
+          CR_PACKAGE_PATH: ".cr-release-packages"
+          # use token for helm-charts repo
+          CR_TOKEN: "${{ secrets.HELM_CHARTER_TOKEN }}"
+          # owner
+          CR_OWNER: "${{ github.repository_owner }}"
+          # index path
+          CR_INDEX_PATH: "index.yaml"

.github/workflows/publish-image.yaml

@@ -0,0 +1,111 @@
+name: Publish Image
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+env:
+  REGISTRY: ghcr.io
+  REPOSITORY: ot-container-kit/redis-operator
+  QuayImageName: quay.io/opstree/redis-operator
+
+jobs:
+  release-ghcr-image:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up docker buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Setup Env
+        run: |
+          echo "TAG=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
+
+      - name: Build and push image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: Dockerfile
+          push: true
+          tags: |
+            ${{ env.REGISTRY }}/${{ env.REPOSITORY }}/redis-operator:${{ env.TAG }}
+            ${{ env.REGISTRY }}/${{ env.REPOSITORY }}/redis-operator:latest
+          platforms: linux/amd64,linux/arm64
+
+  release-quay-image:
+    runs-on: ubuntu-latest
+    environment: release-image
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Login to Quay.io
+        uses: docker/login-action@v3
+        with:
+          registry: quay.io
+          username: ${{ secrets.QUAY_USERNAME }}
+          password: ${{ secrets.QUAY_PASSWORD }}
+
+      - name: Setup Env
+        run: |
+          echo "TAG=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
+
+      - name: Build and push image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            ${{ env.QuayImageName }}:${{ env.TAG }}
+            ${{ env.QuayImageName }}:latest
+
+#   trivy_scan:
+#     needs: [release_image]
+#     runs-on: ubuntu-latest
+#     steps:
+#     - name: Checkout
+#       uses: actions/checkout@v2
+#     - name: Run Trivy vulnerability scanner for arm64 image
+#       uses: aquasecurity/trivy-action@master
+
+#     - name: Run Trivy vulnerability scanner for multi-arch image
+#       uses: aquasecurity/trivy-action@master
+#       with:
+#         image-ref: ${{ env.QuayImageName }}:${{ env.APP_VERSION }}
+#         format: 'template'
+#         template: '@/contrib/sarif.tpl'
+#         output: 'trivy-results-latest.sarif'
+#         exit-code: '1'
+#         ignore-unfixed: true
+#         severity: 'CRITICAL,HIGH'
+#     - name: Run Trivy vulnerability scanner for latest image
+#       uses: aquasecurity/trivy-action@master
+#       with:
+#         image-ref:  ${{ env.QuayImageName }}:latest
+#         format: 'template'
+#         template: '@/contrib/sarif.tpl'
+#         output: 'trivy-results-latest.sarif'
+#         exit-code: '1'
+#         ignore-unfixed: true
+#         severity: 'CRITICAL,HIGH'

.github/workflows/release-images.yaml

@@ -1,75 +0,0 @@
-name: Release container images
-
-on:
-  pull_request:
-    types: [closed]
-    branches:
-      - master
-
-env:
-  ApplicationName: redis-operator
-  QuayImageName: quay.io/opstree/redis-operator
-  AppVersion: "v0.15.1"
-  DOCKERFILE_PATH: '**/Dockerfile'
-
-jobs:
-  setup:
-    if: github.event.pull_request.merged == true
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v2
-
-    - name: Login to Quay.io
-      uses: docker/login-action@v2
-      with:
-        registry: quay.io
-        username: ${{ secrets.QUAY_USERNAME }}
-        password: ${{ secrets.ACCESS_TOKEN }}
-
-  build_multi_arch:
-    needs: setup
-    if: github.event.pull_request.merged == true
-    runs-on: ubuntu-latest
-    steps:
-    - name: Build and push multi-arch latest image
-      uses: docker/build-push-action@v2
-      with:
-        context: .
-        file: ${{ env.DOCKERFILE_PATH }}
-        platforms: linux/amd64,linux/arm64
-        push: true
-        tags: ${{ env.QuayImageName }}:{{ env.AppVersion }}, ${{ env.QuayImageName }}:latest
-
-  trivy_scan:
-    needs: [build_multi_arch]
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Run Trivy vulnerability scanner for arm64 image
-      uses: aquasecurity/trivy-action@master
-      
-    - name: Run Trivy vulnerability scanner for multi-arch image
-      uses: aquasecurity/trivy-action@master
-      with:
-        image-ref: ${{ env.QuayImageName }}:${{ env.AppVersion }}
-        format: 'template'
-        template: '@/contrib/sarif.tpl'
-        output: 'trivy-results-latest.sarif'
-        exit-code: '1'
-        ignore-unfixed: true
-        severity: 'CRITICAL,HIGH'
-    - name: Run Trivy vulnerability scanner for latest image
-      uses: aquasecurity/trivy-action@master
-      with:
-        image-ref:  ${{ env.QuayImageName }}:latest
-        format: 'template'
-        template: '@/contrib/sarif.tpl'
-        output: 'trivy-results-latest.sarif'
-        exit-code: '1'
-        ignore-unfixed: true
-        severity: 'CRITICAL,HIGH'

.github/workflows/stale.yaml

@@ -0,0 +1,56 @@
+# Configuration for stale action workflow - https://github.com/actions/stale
+name: Manage stale issues and PRs
+on:
+  schedule:
+    # Run hourly
+    - cron: '30 1 * * *'
+  workflow_dispatch:
+
+permissions:
+  issues: write
+  pull-requests: write
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+    steps:
+      - uses: actions/stale@v9
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          ascending: true
+          # --- Issues & PRs ---
+          # Number of days of inactivity before an issue or PR becomes stale
+          days-before-stale: 365
+          # Number of days of inactivity before a stale issue or PR is closed
+          days-before-close: 30
+          # API calls per run
+          operations-per-run: 1000
+
+          # --- Issues ---
+          stale-issue-label: "stale"
+          # Comment to post when marking an issue as stale
+          stale-issue-message: >
+            This issue has been automatically marked as stale.
+            **If this issue is still affecting you, please leave any comment** (for example, "bump"), and we'll keep it open.
+            We are sorry that we haven't been able to prioritize it yet. If you have any new additional information, please include it with your comment!
+          # Comment to post when closing a stale issue
+          close-issue-message: >
+            Closing this issue after a prolonged period of inactivity. If this issue is still present in the latest release, please create a new issue with up-to-date information. Thank you!
+          # Issues with these labels will never be considered stale
+          exempt-issue-labels: "enhancement,good first issue,help wanted"
+
+          # --- PRs ---
+          stale-pr-label: "stale"
+          # Comment to post when marking a pull request as stale
+          stale-pr-message: >
+            This pull request has been automatically marked as stale.
+            **If this pull request is still relevant, please leave any comment** (for example, "bump"), and we'll keep it open.
+            We are sorry that we haven't been able to prioritize reviewing it yet. Your contribution is very much appreciated.
+          # Comment to post when closing a stale pull request
+          close-pr-message: >
+            Closing this pull request after a prolonged period of inactivity. If this issue is still present in the latest release, please ask for this pull request to be reopened. Thank you!
+          # PRs with these labels will never be considered stale
+          exempt-pr-labels: ""

.github/workflows/verify-codegen.yaml

@@ -0,0 +1,37 @@
+name: Verify Codegen
+
+on:
+  pull_request:
+    branches:
+      - main
+  push:
+    branches:
+      - main
+
+jobs:
+  verify-codegen:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Free disk space
+      uses: jlumbroso/free-disk-space@v1.3.1
+      with:
+        tool-cache: true
+        android: true
+        dotnet: true
+        haskell: true
+        large-packages: false
+        docker-images: true
+        swap-storage: false
+
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - uses: actions/setup-go@v5
+      with:
+        go-version-file: go.mod
+        cache-dependency-path: go.sum
+
+    - name: Run codegen and verify no diffs
+      run: |
+        make verify-codegen

.gitignore

@@ -13,6 +13,7 @@ testbin/*
 
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
+coverage.html
 
 # Kubernetes Generated files - skip generated files, except for vendored files
 
@@ -24,5 +25,10 @@ testbin/*
 *.swo
 *~
 .vscode
+.go-version
+
+.DS_Store
 
 docs/build
+kubeconfig
+CLAUDE.md

.golangci.yml

@@ -1,45 +1,54 @@
-linters-settings:
-  govet:
-    check-shadowing: true
-  golint:
-    min-confidence: 0.8 
-  gofmt:
-    simplify: true
-
-# linters:
-#   enable-all: true
-#   disable:
-#     - errcheck 
-#     - tagliatelle
-# Exclude the files that are causing the errors
-issues:
-  exclude-rules:
-    - path: _test\.go # Ignore test files for linting
-      linters:
-        - gocyclo
-        - errcheck
-        - dupl
-        - gosec
+version: "2"
 run:
-  timeout: 5m
-  go-version: "1.17"
-  test: false
-  # Exclude third-party packages and go.mod from the lint checks
-  exclude: |
-    '(^vendor/.*|.*_test\.go|go\.mod|.*validatingwebhookconfiguration\.go|.*mutatingwebhookconfiguration\.go)'
-  skip-files:
-    - '^.*validatingwebhookconfiguration\.go$'
-    - controllers/suite_test.go
-  skip-dirs:
-    - k8s.io/client-go
-    - github.com/banzaicloud/k8s-objectmatcher
-    - github.com/go-logr/logr
-    - github.com/go-redis/redis
-    - github.com/onsi/ginkgo
-    - github.com/onsi/gomega
-    - github.com/pkg/errors
-    - k8s.io/api
-    - k8s.io/apimachinery
-    - sigs.k8s.io/controller-runtime
-    - golang.org/x/sys
-    - vendor$, third_party$, testdata$, examples$, Godeps$, builtin$
+  go: 1.23.4
+  tests: true
+linters:
+  enable:
+    - asasalint
+    - asciicheck
+    - bidichk
+    - bodyclose
+    - containedctx
+    - decorder
+    - dogsled
+    - durationcheck
+    - errname
+    - gochecknoinits
+    - goprintffuncname
+    - grouper
+    - importas
+    - makezero
+    - misspell
+    - noctx
+    - nolintlint
+    - nosprintfhostport
+    - thelper
+    - tparallel
+    - unconvert
+    - wastedassign
+    - whitespace
+  exclusions:
+    generated: lax
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling
+    paths:
+      - third_party$
+      - builtin$
+      - examples$
+formatters:
+  enable:
+    - gci
+    - gofmt
+    - gofumpt
+  settings:
+    gofmt:
+      simplify: true
+  exclusions:
+    generated: lax
+    paths:
+      - third_party$
+      - builtin$
+      - examples$

.travis.yml

@@ -5,7 +5,7 @@ install:
   - cd docs; yarn install # npm ci
 branches:
   only:
-    - master
+    - main
 script:
   - cd docs; yarn build # npm run docs:build
 deploy:
@@ -15,4 +15,4 @@ deploy:
   github_token: $GITHUB_TOKEN # A token generated on GitHub allowing Travis to push code on your repository. Set in the Travis settings page of your repository, as a secure variable
   keep_history: true
   on:
-    branch: master
+    branch: main

.yamllint.yml

@@ -0,0 +1,12 @@
+extends: default
+
+rules:
+  line-length:
+    max: 300
+    level: warning
+    allow-non-breakable-words: true
+    allow-non-breakable-inline-mappings: true
+  comments-indentation: disable
+
+ignore:
+  - resources.yaml

CHANGELOG.md

@@ -1,5 +1,229 @@
+### v0.21.0
+##### June 2025 Latest
+
+#### :tada: Features
+
+- Round robin where to transfer cluster shards when scaling in a Redis Cluster #1412
+- Add auto max memory configuration for Redis instances #1411
+- Add bus port configuration for Redis cluster services #1406
+- Add automatic Redis pod role label synchronization for rediscluster #1404
+- RedisCluster observability #1392
+- Add liveness/readiness probes to values.yaml and templates #1378
+- Reduce unnecessary requeue when skip reconcile annotation exists #1374
+- RedisReplication observability, skip reconcile or not #1369
+- Add Redis Sentinel validation webhook for clusterSize #1361
+
+#### :beetle: Bug Fixes
+
+- Resolve StatefulSet selector immutability issues #1382
+- Avoid sentinel restart after replication failover #1381
+- Define named probe port outside webhook block #1354
+
+#### :tada: Refactors
+
+- Reorganize manager agent cmd package #1383
+- Reorganize API structure and update paths #1363
+- Remove useless structure and refactor package #1362
+- Reorganize command structure for Redis operator #1351
+
+### v0.20.2
+##### May 12, 2024
+
+#### :beetle: Bug Fixes
+
+- Handle panic when retrieving StatefulSet in GetRedisNodesByRole #1330
+- VCT resize detection logic; add support for scaling out with new VCT size #1342
+- Service updated before Statefulset during Reconciliation #1348
+
+#### :tada: Features
+
+- Add data assertion generation and enhance Redis configuration commands #1331
+- Add feature gates support for Redis Operator #1333
+- Migrate kubebuilder go.kubebuilder.io/v3 to go.kubebuilder.io/v4 #1340
+
+#### :tada: Refactors
+
+- Define container port for http probes in operator chart #1326
+- Enhance environment variable management and CI workflow #1315
+
+### v0.20.1
+##### April 27, 2024
+
+#### :beetle: Bug Fixes
+
+- Move VCT logic before diff calculation for stateful set #1322
+
+### v0.20.0
+##### April 1, 2024
+
+#### :tada: Features
+
+- Sentinel - support hostname resolve and announce #1247
+- Add redis agent with bootstrap configuration generation #1254
+- Implement comprehensive Redis configuration generation for agent bootstrap #1260
+- Added support for hostport to allow direct connection to the pod #1263
+- Add preStop hook for Redis Cluster failover #1264
+- Sentinel - announce-ip when resolve & announce are set #1271
+- Fix PVC resizing issue and refactor PVC resizing logic #1268
+- Add redisreplication observability #1274
+- Add recreate-stateful-strategy, orphan, background, foreground(default) #1286
+- Update Dockerfile and Makefile for unified operator binary #1294
+- Add support for anti affinity configuration in helm charts #1296
+- Guarantee to avoid bad master ip on Sentinel #1289
+- Add feature gates for sentinel configuration generation in init container #1300
+- Support redis configuration generation in init container #1303
+
+#### :beetle: Bug Fixes
+
+- Replace hardcoded Redis port 6379 with configurable port from cr.Spec.Port #1261
+- Update references from master to main in docs and workflow files #1288
+- Svc finalizer removed #1297
+- Race condition resulting in permanently broken Redis cluster #1298
+
+### v0.19.1
+##### February 19, 2024
+
+#### :warning: Deprecation Notice
+
+The v1beta1 API version will be removed in next release. Users are strongly encouraged to migrate to v1beta2, which offers enhanced features and improved stability.
+
+#### :tada: Features
+
+- Add data-assert tool for Redis data management #1204
+- Check data consistent by external tool #1205
+- Added actions to publish charts to github container registry #1201
+- Add headless service configuration support #1219
+- Update redis-operator cert manager configuration #1220
+- Add additional service configuration with optional enable flag #1228
+- Enhance Redis HA and node scheduling strategy #1237
+- Add securityContext config in chart for redis-exporter #1238
+- Add dynamic Redis configuration support for Redis Cluster #1241
+- Configurable operator maxConcurrentReconciles #1242
+
+#### :beetle: Bug Fixes
+
+- Skip-reconcile annotation still skipping reconcile even the value is false #1202
+- Make recreate statefulset only trigger when value true #1240
+- Improve pod label patching with error handling and retry mechanism #1231
+- Changed certificate serverName to pod+namespace #1221
+- Add missing topologySpreadConstraint on RedisCluster follower #1218
+
+### v0.19.0
+##### January 12, 2024
+
+#### :tada: Features
+
+- Add PDB and probes, drop unspecified acl in sentinel helm #1123
+- Add master/replica service to redis replication #1124
+- Add recreateStatefulSetOnUpdateInvalid helm chart value #1127
+- Enhance RedisReplication controller and CRD with additional status #1154
+- Support PDB in redisreplication #1166
+- Enhance RedisSentinel reconciliation logic and update workflow #1176
+- Support redis-cluster topologySpreadConstraints #1177
+- Add event recording functionality for RedisCluster controller #1182
+- Support topologySpreadConstraints in replication & sentinel #1184
+- Redis-cluster add podAntiAffinity #1180
+- Separate resources section for leader and follower #1188
+- Enhance RedisCluster resource management by introducing separate resource handling for leader and follower #1199
+
+#### :beetle: Bug Fixes
+
+- PDB value mapping in redis-sentinel #1136
+- Chart render error when enable initcontainer #1146
+- InitContainer enabled properties not define in template #1152
+- Redis-cluster unexpected downscaling #1173
+- Reduce the impact of Redis cluster intermediate states #1178
+- Label selector mapping on redisreplication pdb #1191
+
+### v0.18.1
+##### November 7, 2024
+
+#### :tada: Features
+
+- Support setting minReadySeconds on the stateful sets #1023
+- Add tolerations to operator chart #1051
+- Add image pull secret for redis operator #1053
+- Add service monitor to redis sentinel chart #1071
+- Add readiness/liveness probe to redis operator chart #1072
+- Upgrade redis/sentinel image to 7.0.15 #1099
+- Reconcile redissentinel only on master changed #1122
+
+#### :beetle: Bug Fixes
+
+- Fix indentation error when enable additional config #1031
+- Fix field validate error when enable additional config for sentinel #1033
+- Fix unknown field error when upgrade chart #1034
+- Fix bad indentation on redis standalone additional configs #1040
+- Fix attempt to repair disconnected/failed master nodes before failing over #1105
+- Fix set controller probe endpoint handler #1121
+
+### v0.18.0
+##### July 11, 2024
+
+#### :tada: Features
+
+- Added redisReplicationPassword values to connect secured replication #1021
+- Added redis/redisreplication/redissentinel/rediscluster chart #1007
+- Added support for extra volume mounts for redis sentinel #994
+- Added automountServiceAccountToken values for deployment and serviceaccount #991
+- Added securityContext for exporter, initcontainers and sidecars #987
+- Added security context values in operator chart #973
+- Added rolling update sequence from leader to follower #966
+- Added support for configurable probe handlers #934
+- Added redis operator helm chart and release workflow #941
+- Added support for other container engines #947
+
+#### :beetle: Bug Fixes
+
+- Added default port to enable `SENTINEL_PORT` environment #999
+- ReadyReplicas need to be checked in `IsStatefulSetReady` #993
+- watchNamespace value does not take effect in chart #990
+- Sentinel should not reconcile until replication cluster ready #964
+- Return ASAP after handling finalizer #940
+- Check redis replication after handling finalizer #936
+
+### v0.17.0
+##### May 14, 2024
+
+#### :tada: Features
+
+- WATCH_NAMESPACE support multi namespace #919
+- Add workflow to publish image to ghcr #914
+- Probe use built-in, discarded healthcheck.sh #907
+- Implement redis cluster ready state #867
+- Add redisreplication status masterNode #849
+
+#### :beetle: Bug Fixes
+
+- Runtime panic when delete rediscluster which disable persistent #922
+- Runtime panic when storage param is empty #887
+- Exporter can not connect to redis when enable tls #902
+- Update status if not equal #900
+- Should get the really leader count when scale in #885
+- ClusterSlaves result should be cut #884
+- Redis cluster update as scale out #882
+- Add common AddFinalizer for all api #858
+
+### v0.16.0
+##### March 27, 2024
+
+#### :tada: Features
+
+- Added support for multiple CRDs and enhanced functionality
+- Improved test coverage and CI/CD pipeline
+- Enhanced Redis cluster management and scaling capabilities
+- Added support for custom Redis configurations
+- Implemented advanced security features
+
+#### :beetle: Bug Fixes
+
+- Fixed various StatefulSet and service management issues
+- Resolved Redis cluster scaling problems
+- Fixed authentication and TLS connectivity issues
+- Improved error handling and logging
+
 ### v0.15.0 
-##### July 17, 2023 Latest
+##### July 17, 2023
 
 #### :beetle: Bug Fixes
 

CODEOWNERS

@@ -0,0 +1 @@
+* @shubham-cmyk @drivebyer @iamabhishek-dubey

CONTRIBUTING.md

@@ -103,7 +103,7 @@ The structure for Redis operator includes different module's directory. The code
 ```shell
 redis-operator/
 |-- api
-|   |-- v1beta1
+|   |-- v1beta2
 |-- bin
 |-- config
 |   |-- certmanager
@@ -146,7 +146,8 @@ The operator deployment can be done via `helm` cli, we just need to define the c
 
 ```shell
 $ helm upgrade redis-operator ot-helm/redis-operator \
-  --install --namespace ot-operators --set redisOperator.imageName=<custom-url> \
+  --install --create-namespace --namespace ot-operators \
+  --set redisOperator.imageName=<custom-url> \
   --set redisOperator.imageTag=<customTag>
 ```
 
@@ -164,7 +165,7 @@ $ helm upgrade redis-cluster ot-helm/redis-cluster \n
 
 Development of redis docker image is maintained inside a different repository - https://github.com/OT-CONTAINER-KIT/redis. To make any change or suggestion related to Redis docker image, please refer to this repository and make required changes.
 
-In the repository, we have `Dockerfile` for [Redis](https://github.com/OT-CONTAINER-KIT/redis/blob/master/Dockerfile) and [Redis Exporter](https://github.com/OT-CONTAINER-KIT/redis/blob/master/Dockerfile.exporter)
+In the repository, we have `Dockerfile` for [Redis](https://github.com/OT-CONTAINER-KIT/redis/blob/main/Dockerfile) and [Redis Exporter](https://github.com/OT-CONTAINER-KIT/redis/blob/main/Dockerfile.exporter)
 
 For building the docker image for redis and redis exporter, there are simple make commands:
 

Dockerfile

@@ -1,5 +1,5 @@
-# Build the manager binary
-FROM golang:1.17 as builder
+# Build the manager or agent binary
+FROM golang:1.23-alpine3.21 AS builder
 ARG BUILDOS
 ARG BUILDPLATFORM
 ARG BUILDARCH
@@ -8,6 +8,7 @@ ARG TARGETPLATFORM
 ARG TARGETOS
 ARG TARGETARCH
 ARG TARGETVARIANT
+ARG IMG
 
 WORKDIR /workspace
 # Copy the Go Modules manifests
@@ -18,25 +19,27 @@ COPY go.sum go.sum
 RUN go mod download
 
 # Copy the go source
-COPY main.go main.go
+COPY cmd/ cmd/
 COPY api/ api/
-COPY controllers/ controllers/
-COPY k8sutils/ k8sutils/
+COPY internal/ internal/
+COPY mocks/ mocks/
 
 # Build
-ARG LDFLAGS="-s -w"
+ARG LDFLAGS="-s -w -X github.com/OT-CONTAINER-KIT/redis-operator/internal/image.operatorImage=${IMG}"
 ENV GOOS=$TARGETOS
 ENV GOARCH=$TARGETARCH
 ENV CGO_ENABLED=0
 
-RUN GO111MODULE=on go build  -ldflags "${LDFLAGS}" -a -o manager main.go
+# Build the unified binary
+RUN GO111MODULE=on go build -ldflags "${LDFLAGS}" -a -o operator cmd/main.go
 
-# Use distroless as minimal base image to package the manager binary
+# Use distroless as minimal base image to package the binary
 # Refer to https://github.com/GoogleContainerTools/distroless for more details
 FROM gcr.io/distroless/static:nonroot
 LABEL maintainer="The Opstree Opensource <opensource@opstree.com>"
 WORKDIR /
-COPY --from=builder /workspace/manager .
+
+COPY --from=builder /workspace/operator /operator
 USER 65532:65532
 
-ENTRYPOINT ["/manager"]
+ENTRYPOINT ["/operator", "manager"]

LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [2020] [Opstree Solutions]
+   Copyright [2024] [Opstree Solutions]
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

Makefile

@@ -1,7 +1,57 @@
+# ===========================
+# Variables
+# ===========================
+
 # Current Operator version
-VERSION ?= 0.15.0
+VERSION ?= 0.21.0
+
 # Default bundle image tag
 BUNDLE_IMG ?= controller-bundle:$(VERSION)
+
+# Kubernetes version to use for envtest
+ENVTEST_K8S_VERSION = 1.31.0
+
+# Image URL to use for all building/pushing image targets
+IMG ?= quay.io/opstree/redis-operator:v$(VERSION)
+
+# Container engine to use (docker or podman)
+CONTAINER_ENGINE ?= docker
+
+# Platforms for multi-arch builds
+PLATFORMS = "linux/arm64,linux/amd64"
+
+# LDFLAGS for setting the operator image during build
+LDFLAGS ?= "-s -w -X github.com/OT-CONTAINER-KIT/redis-operator/internal/image.operatorImage=$(IMG)"
+
+# Get the currently used golang install path (in GOPATH/bin, unless GOBIN is set)
+ifeq (,$(shell go env GOBIN))
+GOBIN = $(shell go env GOPATH)/bin
+else
+GOBIN = $(shell go env GOBIN)
+endif
+
+# Location to install dependencies to
+LOCALBIN ?= $(shell pwd)/bin
+
+# Tool Binaries
+KUBECTL ?= kubectl
+KUSTOMIZE ?= $(LOCALBIN)/kustomize-$(KUSTOMIZE_VERSION)
+CONTROLLER_GEN ?= $(LOCALBIN)/controller-gen-$(CONTROLLER_TOOLS_VERSION)
+ENVTEST ?= $(LOCALBIN)/setup-envtest-$(ENVTEST_VERSION)
+GOLANGCI_LINT = $(LOCALBIN)/golangci-lint-$(GOLANGCI_LINT_VERSION)
+KUTTL = $(LOCALBIN)/kuttl-$(KUTTL_VERSION)
+KIND = $(LOCALBIN)/kind-$(KIND_VERSION)
+CRD_REF_DOCS = $(LOCALBIN)/crd-ref-docs-$(CRD_REF_DOCS_VERSION)
+
+# Tool Versions
+KUSTOMIZE_VERSION ?= v5.6.0
+CONTROLLER_TOOLS_VERSION ?= v0.17.2
+ENVTEST_VERSION ?= release-0.17
+GOLANGCI_LINT_VERSION ?= v2.2.2
+KUTTL_VERSION ?= 0.15.0
+KIND_VERSION ?= v0.24.0
+CRD_REF_DOCS_VERSION ?= v0.0.12
+
 # Options for 'bundle-build'
 ifneq ($(origin CHANNELS), undefined)
 BUNDLE_CHANNELS := --channels=$(CHANNELS)
@@ -11,102 +61,105 @@ BUNDLE_DEFAULT_CHANNEL := --default-channel=$(DEFAULT_CHANNEL)
 endif
 BUNDLE_METADATA_OPTS ?= $(BUNDLE_CHANNELS) $(BUNDLE_DEFAULT_CHANNEL)
 
-# Image URL to use all building/pushing image targets
-IMG ?= quay.io/opstree/redis-operator:v$(VERSION)
-# Produce CRDs that work back to Kubernetes 1.11 (no version conversion)
-CRD_OPTIONS ?= "crd:trivialVersions=true,preserveUnknownFields=false"
-
-# Get the currently used golang install path (in GOPATH/bin, unless GOBIN is set)
-ifeq (,$(shell go env GOBIN))
-GOBIN=$(shell go env GOPATH)/bin
-else
-GOBIN=$(shell go env GOBIN)
-endif
+# ===========================
+# Targets
+# ===========================
 
+# Default target
 all: manager
 
 # Run tests
-ENVTEST_ASSETS_DIR=$(shell pwd)/testbin
+.PHONY: test
 test: generate fmt vet manifests
-	mkdir -p ${ENVTEST_ASSETS_DIR}
-	test -f ${ENVTEST_ASSETS_DIR}/setup-envtest.sh || curl -sSLo ${ENVTEST_ASSETS_DIR}/setup-envtest.sh https://raw.githubusercontent.com/kubernetes-sigs/controller-runtime/v0.7.0/hack/setup-envtest.sh
-	source ${ENVTEST_ASSETS_DIR}/setup-envtest.sh; fetch_envtest_tools $(ENVTEST_ASSETS_DIR); setup_envtest_env $(ENVTEST_ASSETS_DIR); go test ./... -coverprofile cover.out
+	KUBEBUILDER_ASSETS="$(shell $(ENVTEST) use $(ENVTEST_K8S_VERSION) -p path)" go test ./... -coverprofile cover.out
 
 # Build manager binary
+.PHONY: manager
 manager: generate fmt vet
-	go build -o bin/manager main.go
+	go build -ldflags $(LDFLAGS) -o bin/manager cmd/main.go
+
+# Build agent binary
+.PHONY: agent
+agent: generate fmt vet
+	go build -o bin/agent cmd/agent/main.go
 
 # Run against the configured Kubernetes cluster in ~/.kube/config
+.PHONY: run
 run: generate fmt vet manifests
-	go run ./main.go
+	go run cmd/main.go
 
 # Install CRDs into a cluster
+.PHONY: install
 install: manifests kustomize
 	$(KUSTOMIZE) build config/crd | kubectl apply --server-side=true -f -
 
 # Uninstall CRDs from a cluster
+.PHONY: uninstall
 uninstall: manifests kustomize
 	$(KUSTOMIZE) build config/crd | kubectl delete -f -
 
 # Deploy controller in the configured Kubernetes cluster in ~/.kube/config
+.PHONY: deploy
 deploy: manifests kustomize
 	cd config/manager && $(KUSTOMIZE) edit set image controller=${IMG}
-	$(KUSTOMIZE) build config/default | kubectl apply -f -
+	$(KUSTOMIZE) build config/default | kubectl apply --server-side=true -f -
 
 # UnDeploy controller from the configured Kubernetes cluster in ~/.kube/config
+.PHONY: undeploy
 undeploy:
 	$(KUSTOMIZE) build config/default | kubectl delete -f -
 
 # Generate manifests e.g. CRD, RBAC etc.
+.PHONY: manifests
 manifests: controller-gen
-	$(CONTROLLER_GEN) $(CRD_OPTIONS) rbac:roleName=manager-role webhook paths="./..." output:crd:artifacts:config=config/crd/bases
+	$(CONTROLLER_GEN) crd rbac:roleName=manager-role webhook paths="./api/..." output:crd:artifacts:config=config/crd/bases
+
+# Sync CRDs to chart directory
+.PHONY: sync-crds
+sync-crds: manifests kustomize
+	@echo "Syncing CRDs to chart directory..."
+	$(KUSTOMIZE) build config/crd > charts/redis-operator/crds/crds.yaml
+	@echo "CRDs synced successfully to charts/redis-operator/crds/crds.yaml"
 
 # Run go fmt against code
+.PHONY: fmt
 fmt:
 	go fmt ./...
 
 # Run go vet against code
+.PHONY: vet
 vet:
 	go vet ./...
 
 # Generate code
+.PHONY: generate
 generate: controller-gen
 	$(CONTROLLER_GEN) object:headerFile="hack/boilerplate.go.txt" paths="./..."
 
+# Generate API documentation
+.PHONY: generate-api-docs
+generate-api-docs:
+	@hack/api-docs/build.sh
+
+# Create a new builder instance for Docker Buildx with the specified platforms and set it as the current builder
+.PHONY: docker-create
 docker-create:
-	docker buildx create --platform "linux/amd64,linux/arm64" --use
+	${CONTAINER_ENGINE} buildx create --platform $(PLATFORMS) --use
 
-# Build the docker image
+# Build the manager Docker image
+.PHONY: docker-build
 docker-build:
-	docker buildx build --platform="linux/arm64,linux/amd64" -t ${IMG} .
+	${CONTAINER_ENGINE} buildx build --platform=$(PLATFORMS) --build-arg IMG=${IMG} -t ${IMG} -f Dockerfile .
 
-# Push the docker image
+# Push the manager Docker image
+.PHONY: docker-push
 docker-push:
-	docker buildx build --push --platform="linux/arm64,linux/amd64" -t ${IMG} .
+	${CONTAINER_ENGINE} buildx build --push --platform="$(PLATFORMS)" --build-arg IMG=${IMG} -t ${IMG} -f Dockerfile .
 
-# Download controller-gen locally if necessary
-CONTROLLER_GEN = $(shell pwd)/bin/controller-gen
-controller-gen:
-	$(call go-install-tool,$(CONTROLLER_GEN),sigs.k8s.io/controller-tools/cmd/controller-gen@v0.4.1)
-
-# Download kustomize locally if necessary
-KUSTOMIZE = $(shell pwd)/bin/kustomize
-kustomize:
-	$(call go-install-tool,$(KUSTOMIZE),sigs.k8s.io/kustomize/kustomize/v3@v3.8.7)
-
-# go-install-tool will 'go install' any package $2 and install it to $1.
-PROJECT_DIR := $(shell dirname $(abspath $(lastword $(MAKEFILE_LIST))))
-define go-install-tool
-@[ -f $(1) ] || { \
-set -e ;\
-TMP_DIR=$$(mktemp -d) ;\
-cd $$TMP_DIR ;\
-go mod init tmp ;\
-echo "Downloading $(2)" ;\
-GOBIN=$(PROJECT_DIR)/bin go install $(2) ;\
-rm -rf $$TMP_DIR ;\
-}
-endef
+# Load the manager image into docker
+.PHONY: docker-load
+docker-load:
+	${CONTAINER_ENGINE} buildx build --load --build-arg IMG=${IMG} -t ${IMG} -f Dockerfile .
 
 # Generate bundle manifests and metadata, then validate generated files.
 .PHONY: bundle
@@ -119,4 +172,122 @@ bundle: manifests kustomize
 # Build the bundle image.
 .PHONY: bundle-build
 bundle-build:
-	docker buildx build --platform="linux/arm64,linux/amd64" -f bundle.Dockerfile -t $(BUNDLE_IMG) .
+	${CONTAINER_ENGINE} buildx build --platform="$(PLATFORMS)" -f bundle.Dockerfile -t $(BUNDLE_IMG) .
+
+# Rebuild all generated code
+.PHONY: codegen
+codegen: generate manifests sync-crds generate-dataAssert generate-metricsdocs generate-api-docs
+
+# Verify that codegen is up to date.
+.PHONY: verify-codegen
+verify-codegen: codegen
+	@echo Checking codegen is up to date... >&2
+	@if [ -n "$$(git status --porcelain)" ]; then \
+		echo "There are uncommitted changes or untracked files after running codegen:" >&2; \
+		git status --porcelain >&2; \
+		echo "To correct this, locally run 'make codegen', commit the changes, and re-run tests." >&2; \
+		exit 1; \
+	fi
+
+# ===========================
+# Testing
+# ===========================
+
+.PHONY: tests
+tests: integration-test-setup unit-tests integration-tests
+
+.PHONY: unit-tests
+unit-tests:
+	@echo Running tests... >&2
+	@go test ./... -race -coverprofile=coverage.out -covermode=atomic
+	@go tool cover -html=coverage.out
+
+.PHONY: e2e-test
+e2e-test: e2e-kind-setup kuttl
+	$(LOCALBIN)/kuttl test --config tests/_config/kuttl-test.yaml
+
+.PHONY: integration-test-setup
+integration-test-setup:
+	./hack/integrationSetup.sh
+
+.PHONY: integration-tests
+integration-tests:
+	ginkgo -r -race --repeat=5
+
+.PHONY: e2e-kind-setup
+e2e-kind-setup:
+	${CONTAINER_ENGINE} build -t redis-operator:e2e -f Dockerfile .
+	$(KIND) create cluster --config tests/_config/kind-config.yaml
+	$(KIND) load docker-image redis-operator:e2e --name kind
+	make deploy IMG=redis-operator:e2e
+
+# ===========================
+# Dependencies
+# ===========================
+
+$(LOCALBIN):
+	mkdir -p $(LOCALBIN)
+
+# Download kustomize locally if necessary.
+.PHONY: kustomize
+kustomize: $(KUSTOMIZE)
+$(KUSTOMIZE): $(LOCALBIN)
+	$(call go-install-tool,$(KUSTOMIZE),sigs.k8s.io/kustomize/kustomize/v5,$(KUSTOMIZE_VERSION))
+
+# Download controller-gen locally if necessary.
+.PHONY: controller-gen
+controller-gen: $(CONTROLLER_GEN)
+$(CONTROLLER_GEN): $(LOCALBIN)
+	$(call go-install-tool,$(CONTROLLER_GEN),sigs.k8s.io/controller-tools/cmd/controller-gen,$(CONTROLLER_TOOLS_VERSION))
+
+# Download setup-envtest locally if necessary.
+.PHONY: envtest
+envtest: $(ENVTEST)
+$(ENVTEST): $(LOCALBIN)
+	$(call go-install-tool,$(ENVTEST),sigs.k8s.io/controller-runtime/tools/setup-envtest,$(ENVTEST_VERSION))
+
+# Download golangci-lint locally if necessary.
+.PHONY: golangci-lint
+golangci-lint: $(GOLANGCI_LINT)
+$(GOLANGCI_LINT): $(LOCALBIN)
+	$(call go-install-tool,$(GOLANGCI_LINT),github.com/golangci/golangci-lint/cmd/golangci-lint,${GOLANGCI_LINT_VERSION})
+
+# Download kind locally if necessary.
+.PHONY: kind
+kind: $(KIND)
+$(KIND): $(LOCALBIN)
+	$(call go-install-tool,$(KIND),sigs.k8s.io/kind,${KIND_VERSION})
+
+# Download kuttl locally if necessary.
+.PHONY: kuttl
+kuttl: $(KUTTL)
+$(KUTTL): $(LOCALBIN)
+	curl -L https://github.com/kudobuilder/kuttl/releases/download/v$(KUTTL_VERSION)/kubectl-kuttl_$(KUTTL_VERSION)_linux_x86_64 -o $(LOCALBIN)/kuttl
+	chmod +x $(LOCALBIN)/kuttl
+
+.PHONY: generate-metricsdocs
+generate-metricsdocs:
+	@mkdir -p $(shell pwd)/docs/content/en/docs/Monitoring
+	@go run ./internal/monitoring/metricsdocs > docs/content/en/docs/Monitoring/metrics.md
+
+.PHONY: generate-dataAssert
+generate-dataAssert:
+	@cd tests/data-assert && go run main.go gen-resource-yaml
+
+# ===========================
+# Helper Functions
+# ===========================
+
+# go-install-tool will 'go install' any package with custom target and name of binary, if it doesn't exist
+# $1 - target path with name of binary (ideally with version)
+# $2 - package url which can be installed
+# $3 - specific version of package
+define go-install-tool
+@[ -f $(1) ] || { \
+set -e; \
+package=$(2)@$(3) ;\
+echo "Downloading $${package}" ;\
+GOBIN=$(LOCALBIN) go install $${package} ;\
+mv "$$(echo "$(1)" | sed "s/-$(3)$$//")" $(1) ;\
+}
+endef

PROJECT

@@ -4,12 +4,12 @@
 # More info: https://book.kubebuilder.io/reference/project-config.html
 domain: redis.opstreelabs.in
 layout:
-- go.kubebuilder.io/v3
+- go.kubebuilder.io/v4
 plugins:
   manifests.sdk.operatorframework.io/v2: {}
   scorecard.sdk.operatorframework.io/v2: {}
 projectName: redis-operator
-repo: redis-operator
+repo: github.com/OT-CONTAINER-KIT/redis-operator
 resources:
 - api:
     crdVersion: v1
@@ -17,11 +17,8 @@ resources:
   domain: redis.opstreelabs.in
   group: redis
   kind: Redis
-  path: redis-operator/api/v1beta2
+  path: redis-operator/api/redis/v1beta2
   version: v1beta2
-  webhooks:
-    conversion: true
-    webhookVersion: v1
 - api:
     crdVersion: v1
     namespaced: true
@@ -29,63 +26,29 @@ resources:
   domain: redis.opstreelabs.in
   group: redis
   kind: RedisCluster
-  path: redis-operator/api/v1beta2
+  path: redis-operator/api/rediscluster/v1beta2
   version: v1beta2
-  webhooks:
-    conversion: true
-    webhookVersion: v1
 - api:
     crdVersion: v1
   controller: true
   domain: redis.opstreelabs.in
   group: redis
   kind: RedisReplication
-  path: redis-operator/api/v1beta2
+  path: redis-operator/api/redisreplication/v1beta2
   version: v1beta2
-  webhooks:
-    conversion: true
-    webhookVersion: v1
 - api:
     crdVersion: v1
   controller: true
   domain: redis.opstreelabs.in
   group: redis
   kind: RedisSentinel
-  path: redis-operator/api/v1beta2
+  path: redis-operator/api/redissentinel/v1beta2
   version: v1beta2
+- group: core
+  kind: Pod
+  path: k8s.io/api/core/v1
+  version: v1
   webhooks:
-    conversion: true
+    defaulting: true
     webhookVersion: v1
-- api:
-    crdVersion: v1
-    namespaced: true
-  domain: redis.opstreelabs.in
-  group: redis
-  kind: Redis
-  path: redis-operator/api/v1beta1
-  version: v1beta1
-- api:
-    crdVersion: v1
-    namespaced: true
-  domain: redis.opstreelabs.in
-  group: redis
-  kind: RedisCluster
-  path: redis-operator/api/v1beta1
-  version: v1beta1
-- api:
-    crdVersion: v1
-    namespaced: true
-  domain: redis.opstreelabs.in
-  group: redis
-  kind: RedisReplication
-  path: redis-operator/api/v1beta1
-  version: v1beta1
-- api:
-    crdVersion: v1
-    namespaced: true
-  domain: redis.opstreelabs.in
-  group: redis
-  kind: RedisSentinel
-  path: redis-operator/api/v1beta1
-  version: v1beta1
 version: "3"

README.md

@@ -3,8 +3,8 @@
 </p>
 
 <p align="center">
-  <a href="https://dev.azure.com/opstreedevops/DevOps/_apis/build/status/redis-operator/redis-operator?repoName=OT-CONTAINER-KIT%2Fredis-operator&branchName=master">
-    <img src="https://dev.azure.com/opstreedevops/DevOps/_apis/build/status/redis-operator/redis-operator?repoName=OT-CONTAINER-KIT%2Fredis-operator&branchName=master" alt="Azure Pipelines">
+  <a href="https://github.com/OT-CONTAINER-KIT/redis-operator/actions/workflows/ci.yaml">
+    <img src="https://github.com/OT-CONTAINER-KIT/redis-operator/actions/workflows/ci.yaml/badge.svg" alt="CI Pipeline">
   </a>
   <a href="https://goreportcard.com/report/github.com/OT-CONTAINER-KIT/redis-operator">
     <img src="https://goreportcard.com/badge/github.com/OT-CONTAINER-KIT/redis-operator" alt="GoReportCard">
@@ -18,18 +18,18 @@
   <a href="https://quay.io/repository/opstree/redis-operator">
     <img src="https://img.shields.io/badge/container-ready-green" alt="Docker">
   </a>
-  <a href="https://github.com/OT-CONTAINER-KIT/redis-operator/master/LICENSE">
+  <a href="https://github.com/OT-CONTAINER-KIT/redis-operator/main/LICENSE">
     <img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="License">
   </a>
 </p>
 
-A Golang based redis operator that will make/oversee Redis standalone and cluster mode setup on top of the Kubernetes. It can create a redis cluster setup with best practices on Cloud as well as the Bare metal environment. Also, it provides an in-built monitoring capability using redis-exporter.
+A Golang-based Redis operator that will make/oversee Redis standalone and cluster mode setup on top of Kubernetes. It can create a Redis cluster setup with best practices on Cloud as well as the bare metal environment. Also, it provides an in-built monitoring capability using redis-exporter.
 
-For documentation, please refer to https://ot-redis-operator.netlify.app/
+For documentation, please refer to <https://redis-operator.opstree.dev/>
 
-Organizations that are using Redis Operator to manage their redis workload can be found [here](./USED_BY_ORGANIZATIONS.md). If your organization is also using Redis Operator, please free to add by creating a [pull request](https://github.com/OT-CONTAINER-KIT/redis-operator/pulls)
+Organizations that are using Redis Operator to manage their Redis workload can be found [here](./USED_BY_ORGANIZATIONS.md). If your organization is also using Redis Operator, please feel free to add by creating a [pull request](https://github.com/OT-CONTAINER-KIT/redis-operator/pulls)
 
-This operator only supports versions of redis `=>6`.
+This operator only supports versions of Redis `>=6`.
 
 ## Architecture
 
@@ -39,95 +39,94 @@ This operator only supports versions of redis `=>6`.
 
 ## Purpose
 
-There are multiple problems that people face while setting up redis setup on Kubernetes, specially cluster type setup. The purpose of creating this opperator is to provide an easy and production ready interface for redis setup that include best-practices, security controls, monitoring, and management.
+There are multiple problems that people face while setting up Redis setup on Kubernetes, especially cluster type setup. The purpose of creating this operator is to provide an easy and production-ready interface for Redis setup that includes best-practices, security controls, monitoring, and management.
 
 ## Supported Features
 
-Here the features which are supported by this operator:-
+Here are the features which are supported by this operator:
 
 - Redis cluster and standalone mode setup
 - Redis cluster failover and recovery
 - Inbuilt monitoring with redis exporter
-- Password and password-less setup of redis
+- Password and password-less setup of Redis
 - TLS support for additional security layer
-- Ipv4 and Ipv6 support for redis setup
-- Detailed monitoring grafana dashboard
-
-## Getting Started
-
-If you want to deploy redis-operator from scratch to a local Minikube cluster, begin with the [Getting started](https://ot-container-kit.github.io/redis-operator/#/quickstart/quickstart) document. It will guide your through the setup step-by-step.
-
-The configuration of Redis setup should be described in [CRD definitions](config/crd/bases). All the examples related to redis standalone and cluster setup can be found inside [example](./example) folder.
+- IPv4 and IPv6 support for Redis setup
+- Detailed monitoring Grafana dashboard
 
 ## Prerequisites
 
-Redis operator requires a Kubernetes cluster of version `>=1.18.0`. If you have just started with Operators, it's highly recommended using the latest version of Kubernetes.
+Redis Operator requires a Kubernetes cluster of version `>=1.18.0`. If you have just started with Operators, it's highly recommended using the latest version of Kubernetes.
 
 ## Image Compatibility
 
 The following table shows the compatibility between the Operator Version, Redis Image, Sentinel Image, and Exporter Image:
 
 | Operator Version | Redis Image | Sentinel Image | Exporter Image |
-|------------------|-------------|----------------|----------------|
-| v0.15.0          | v7.0.12     | v7.0.12        | v1.48.0        |
-| v0.15.0          | v7.0.11     | v7.0.11        | v1.48.0        |
-| v0.14.0          | v7.0.7      | v7.0.7         | v1.48.0        |
-| v0.13.0          | v6.2.5      | nil            | v1.48.0        |
+| ---------------- | ----------- | -------------- | -------------- |
+| v0.19.x          | > v7.0.12, >=v6.2.14     | > v7.0.12, >= v6.2.14        | v1.44.0        |
+| v0.18.x          | v7.0.12     | v7.0.12        | v1.44.0        |
+| v0.17.0          | v7.0.12     | v7.0.12        | v1.44.0        |
+| v0.16.0          | v7.0.12     | v7.0.12        | v1.44.0        |
+| v0.15.1          | v7.0.12     | v7.0.12        | v1.44.0        |
+| v0.15.0          | v7.0.11     | v7.0.11        | v1.44.0        |
+| v0.14.0          | v7.0.7      | v7.0.7         | v1.44.0        |
+| v0.13.0          | v6.2.5      | nil            | v1.44.0        |
 
 ## Quickstart
 
-The setup can be done by using helm. If you want to see more example, please go through the [example](./example) folder.
+The setup can be done by using Helm. If you want to see more examples, please go through the [example](./example) folder.
 
-But you can simply use the helm chart for installation.
+But you can simply use the Helm chart for installation.
 
 ```shell
-# Add the helm chart
+# Add the Helm chart
 $ helm repo add ot-helm https://ot-container-kit.github.io/helm-charts/
 ```
 
 ```shell
-# Deploy the redis-operator
-$ helm upgrade redis-operator ot-helm/redis-operator --install --namespace ot-operators
+# Deploy the Redis operator
+$ helm upgrade redis-operator ot-helm/redis-operator \
+  --install --create-namespace --namespace ot-operators
 ```
 
-After deployment, verify the installation of operator
+After deployment, verify the installation of the operator
 
 ```shell
 helm test redis-operator --namespace ot-operators
 ```
 
-Creating redis cluster, standalone, replication and sentinel setup.
+Creating Redis cluster, standalone, replication and sentinel setup.
 
 ```shell
-# Create redis cluster setup
+# Create Redis cluster setup
 $ helm upgrade redis-cluster ot-helm/redis-cluster \
   --set redisCluster.clusterSize=3 --install \
   --namespace ot-operators
 ```
 
 ```shell
-# Create redis standalone setup
+# Create Redis standalone setup
 $ helm upgrade redis ot-helm/redis \
   --install --namespace ot-operators
 ```
 
 ```shell
-# Create redis replication setup
+# Create Redis replication setup
 $ helm upgrade redis-replication ot-helm/replication \
   --install --namespace ot-operators
 ```
 
 ```shell
-# Create redis sentinel setup
+# Create Redis sentinel setup
 $ helm upgrade redis-sentinel ot-helm/sentinel \
   --install --namespace ot-operators
 ```
 
-If you want to customize the value file by yourself while initializing the helm command, the values files for reference are present [here](https://github.com/OT-CONTAINER-KIT/helm-charts/tree/main/charts/redis-setup).
+If you want to customize the values file by yourself while initializing the Helm command, the values files for reference are present [here](https://github.com/OT-CONTAINER-KIT/helm-charts/tree/main/charts/redis-setup).
 
 ## Monitoring with Prometheus
 
-To monitor redis performance we will be using prometheus. In any case, extra prometheus configuration will not be required because we will be using the Prometheus service discover pattern. For that we already have set these annotations:-
+To monitor Redis performance we will be using Prometheus. In any case, extra Prometheus configuration will not be required because we will be using the Prometheus service discovery pattern. For that we already have set these annotations:
 
 ```yaml
   annotations:
@@ -148,4 +147,4 @@ Please see our [CHANGELOG.md](./CHANGELOG.md) for details.
 
 This project is managed by [OpsTree Solutions](http://opstree.com). For any queries or suggestions, you can reach out to us at [opensource@opstree.com](mailto:opensource@opstree.com).
 
-Join our Slack Channel: [#redis-operator](https://opstree.slack.com/archives/C05MBRB50JG).
+Join our Slack Channel: [#redis-operator](https://join.slack.com/t/opstree/shared_invite/zt-3o8jp35x-UGMU2Cy0WSBk3Lbzqa2wVw).

ROADMAP.md

@@ -0,0 +1,19 @@
+# Phase 1: Feature Expansion and Advanced Configuration (0-6 months)
+
+- Advance Backup and Restore
+    - Automated Backup Policies: Users can define more complex backup strategies (e.g., time-based, event-triggered, incremental backups).
+    - Backup on Redis Persistence Options: Integrate support for Redis persistence modes like RDB snapshots and AOF (Append-Only File).
+ 
+- Redis Stream and Pub/Sub Support
+    - Add support for Redis Streams and Pub/Sub messaging patterns, allowing users to manage Redis Stream-based applications directly through the operator.
+ 
+- Valkey Support
+		- Adding support for Valkey standalone.
+		- Adding support for Valkey replication.
+		- Adding support for Valkey cluster mode.
+		- Adding TLS-based authentication.
+		- Adding password-based authentication support.
+		- Encryption support.
+		- Persistence support.
+		- Monitoring feature.
+		- Different Kubernetes native support like PDB, sidecar, tolerations, upgrade strategy.

api/common/v1beta2/common_types.go

@@ -0,0 +1,276 @@
+package v1beta2
+
+import (
+	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
+)
+
+// KubernetesConfig will be the JSON struct for Basic Redis Config
+// +k8s:deepcopy-gen=true
+type KubernetesConfig struct {
+	Image                                string                                                  `json:"image"`
+	ImagePullPolicy                      corev1.PullPolicy                                       `json:"imagePullPolicy,omitempty"`
+	Resources                            *corev1.ResourceRequirements                            `json:"resources,omitempty"`
+	ExistingPasswordSecret               *ExistingPasswordSecret                                 `json:"redisSecret,omitempty"`
+	ImagePullSecrets                     *[]corev1.LocalObjectReference                          `json:"imagePullSecrets,omitempty"`
+	UpdateStrategy                       appsv1.StatefulSetUpdateStrategy                        `json:"updateStrategy,omitempty"`
+	PersistentVolumeClaimRetentionPolicy *appsv1.StatefulSetPersistentVolumeClaimRetentionPolicy `json:"persistentVolumeClaimRetentionPolicy,omitempty"`
+	Service                              *ServiceConfig                                          `json:"service,omitempty"`
+	IgnoreAnnotations                    []string                                                `json:"ignoreAnnotations,omitempty"`
+	MinReadySeconds                      *int32                                                  `json:"minReadySeconds,omitempty"`
+}
+
+func (in *KubernetesConfig) GetServiceType() string {
+	if in.Service == nil {
+		return "ClusterIP"
+	}
+	return in.Service.ServiceType
+}
+
+func (in *KubernetesConfig) GetServiceAnnotations() map[string]string {
+	if in.Service == nil {
+		return nil
+	}
+	return in.Service.ServiceAnnotations
+}
+
+func (in *KubernetesConfig) GetHeadlessServiceAnnotations() map[string]string {
+	if in.Service == nil {
+		return nil
+	}
+	if in.Service.Headless == nil {
+		return nil
+	}
+	return in.Service.Headless.AdditionalAnnotations
+}
+
+// ShouldCreateAdditionalService returns whether additional service should be created
+func (in *KubernetesConfig) ShouldCreateAdditionalService() bool {
+	if in.Service == nil {
+		return true
+	}
+	if in.Service.Additional == nil {
+		return true
+	}
+	if in.Service.Additional.Enabled == nil {
+		return true
+	}
+	return *in.Service.Additional.Enabled
+}
+
+// ShouldIncludeBusPort returns whether bus port should be included in the service
+func (in *KubernetesConfig) ShouldIncludeBusPort() bool {
+	if in.Service == nil {
+		return false
+	}
+	if in.Service.IncludeBusPort == nil {
+		return false
+	}
+	return *in.Service.IncludeBusPort
+}
+
+// ShouldIncludeBusPortForHeadless returns whether bus port should be included in the headless service
+func (in *KubernetesConfig) ShouldIncludeBusPortForHeadless() bool {
+	if in.Service == nil {
+		return false
+	}
+	if in.Service.Headless == nil {
+		return false
+	}
+	if in.Service.Headless.IncludeBusPort == nil {
+		return false
+	}
+	return *in.Service.Headless.IncludeBusPort
+}
+
+// ShouldIncludeBusPortForAdditional returns whether bus port should be included in the additional service
+func (in *KubernetesConfig) ShouldIncludeBusPortForAdditional() bool {
+	if in.Service == nil {
+		return false
+	}
+	if in.Service.Additional == nil {
+		return false
+	}
+	if in.Service.Additional.IncludeBusPort == nil {
+		return false
+	}
+	return *in.Service.Additional.IncludeBusPort
+}
+
+// ServiceConfig define the type of service to be created and its annotations
+// +k8s:deepcopy-gen=true
+type ServiceConfig struct {
+	// +kubebuilder:validation:Enum=LoadBalancer;NodePort;ClusterIP
+	ServiceType        string            `json:"serviceType,omitempty"`
+	ServiceAnnotations map[string]string `json:"annotations,omitempty"`
+	// IncludeBusPort when set to true, it will add bus port to the service, such as 16379.
+	// This field is only used for Redis cluster mode.
+	IncludeBusPort *bool `json:"includeBusPort,omitempty"`
+	// Headless config for which suffix is -headless service
+	Headless *Service `json:"headless,omitempty"`
+	// Additional config for which suffix is -additional service
+	Additional *Service `json:"additional,omitempty"`
+}
+
+// Service is the struct to define the service type and its annotations
+// +k8s:deepcopy-gen=true
+type Service struct {
+	// +kubebuilder:validation:Enum=LoadBalancer;NodePort;ClusterIP
+	// +kubebuilder:default:=ClusterIP
+	Type                  string            `json:"type,omitempty"`
+	AdditionalAnnotations map[string]string `json:"additionalAnnotations,omitempty"`
+	// IncludeBusPort when set to true, it will add bus port to the service, such as 16379.
+	// This field is only used for Redis cluster mode.
+	IncludeBusPort *bool `json:"includeBusPort,omitempty"`
+	// +kubebuilder:default:=true
+	Enabled *bool `json:"enabled,omitempty"`
+}
+
+// ExistingPasswordSecret is the struct to access the existing secret
+// +k8s:deepcopy-gen=true
+type ExistingPasswordSecret struct {
+	Name *string `json:"name,omitempty"`
+	Key  *string `json:"key,omitempty"`
+}
+
+// RedisExporter interface will have the information for redis exporter related stuff
+// +k8s:deepcopy-gen=true
+type RedisExporter struct {
+	Enabled bool `json:"enabled,omitempty"`
+	// +kubebuilder:default:=9121
+	Port            *int                         `json:"port,omitempty"`
+	Image           string                       `json:"image"`
+	Resources       *corev1.ResourceRequirements `json:"resources,omitempty"`
+	ImagePullPolicy corev1.PullPolicy            `json:"imagePullPolicy,omitempty"`
+	EnvVars         *[]corev1.EnvVar             `json:"env,omitempty"`
+	SecurityContext *corev1.SecurityContext      `json:"securityContext,omitempty"`
+}
+
+// RedisConfig defines the external configuration of Redis
+// +k8s:deepcopy-gen=true
+type RedisConfig struct {
+	// MaxMemoryPercentOfLimit is the percentage of redis container memory limit to be used as maxmemory.
+	// +kubebuilder:validation:Minimum=1
+	// +kubebuilder:validation:Maximum=100
+	MaxMemoryPercentOfLimit *int     `json:"maxMemoryPercentOfLimit,omitempty"`
+	DynamicConfig           []string `json:"dynamicConfig,omitempty"`
+	AdditionalRedisConfig   *string  `json:"additionalRedisConfig,omitempty"`
+}
+
+// Storage is the inteface to add pvc and pv support in redis
+// +k8s:deepcopy-gen=true
+type Storage struct {
+	KeepAfterDelete     bool                         `json:"keepAfterDelete,omitempty"`
+	VolumeClaimTemplate corev1.PersistentVolumeClaim `json:"volumeClaimTemplate,omitempty"`
+	VolumeMount         AdditionalVolume             `json:"volumeMount,omitempty"`
+}
+
+// Additional Volume is provided by user that is mounted on the pods
+// +k8s:deepcopy-gen=true
+type AdditionalVolume struct {
+	Volume    []corev1.Volume      `json:"volume,omitempty"`
+	MountPath []corev1.VolumeMount `json:"mountPath,omitempty"`
+}
+
+// TLS Configuration for redis instances
+// +k8s:deepcopy-gen=true
+type TLSConfig struct {
+	CaKeyFile   string `json:"ca,omitempty"`
+	CertKeyFile string `json:"cert,omitempty"`
+	KeyFile     string `json:"key,omitempty"`
+	// Reference to secret which contains the certificates
+	Secret corev1.SecretVolumeSource `json:"secret"`
+}
+
+// Sidecar for each Redis pods
+// +k8s:deepcopy-gen=true
+type Sidecar struct {
+	Name            string                       `json:"name"`
+	Image           string                       `json:"image"`
+	ImagePullPolicy corev1.PullPolicy            `json:"imagePullPolicy,omitempty"`
+	Resources       *corev1.ResourceRequirements `json:"resources,omitempty"`
+	EnvVars         *[]corev1.EnvVar             `json:"env,omitempty"`
+	Volumes         *[]corev1.VolumeMount        `json:"mountPath,omitempty"`
+	Command         []string                     `json:"command,omitempty" protobuf:"bytes,3,rep,name=command"`
+	Ports           *[]corev1.ContainerPort      `json:"ports,omitempty" patchStrategy:"merge" patchMergeKey:"containerPort" protobuf:"bytes,6,rep,name=ports"`
+	SecurityContext *corev1.SecurityContext      `json:"securityContext,omitempty"`
+}
+
+// RedisLeader interface will have the redis leader configuration
+// +k8s:deepcopy-gen=true
+type RedisLeader struct {
+	// Replicas overrides clusterSize for leader nodes count. If not set, uses clusterSize value
+	Replicas                  *int32                            `json:"replicas,omitempty"`
+	RedisConfig               *RedisConfig                      `json:"redisConfig,omitempty"`
+	Affinity                  *corev1.Affinity                  `json:"affinity,omitempty"`
+	PodDisruptionBudget       *RedisPodDisruptionBudget         `json:"pdb,omitempty"`
+	ReadinessProbe            *corev1.Probe                     `json:"readinessProbe,omitempty" protobuf:"bytes,11,opt,name=readinessProbe"`
+	LivenessProbe             *corev1.Probe                     `json:"livenessProbe,omitempty" protobuf:"bytes,12,opt,name=livenessProbe"`
+	Tolerations               *[]corev1.Toleration              `json:"tolerations,omitempty"`
+	NodeSelector              map[string]string                 `json:"nodeSelector,omitempty"`
+	TopologySpreadConstraints []corev1.TopologySpreadConstraint `json:"topologySpreadConstraints,omitempty"`
+}
+
+// RedisFollower interface will have the redis follower configuration
+// +k8s:deepcopy-gen=true
+type RedisFollower struct {
+	// Replicas overrides clusterSize for follower nodes count. If not set, uses clusterSize value
+	Replicas                  *int32                            `json:"replicas,omitempty"`
+	RedisConfig               *RedisConfig                      `json:"redisConfig,omitempty"`
+	Affinity                  *corev1.Affinity                  `json:"affinity,omitempty"`
+	PodDisruptionBudget       *RedisPodDisruptionBudget         `json:"pdb,omitempty"`
+	ReadinessProbe            *corev1.Probe                     `json:"readinessProbe,omitempty" protobuf:"bytes,11,opt,name=readinessProbe"`
+	LivenessProbe             *corev1.Probe                     `json:"livenessProbe,omitempty" protobuf:"bytes,12,opt,name=livenessProbe"`
+	Tolerations               *[]corev1.Toleration              `json:"tolerations,omitempty"`
+	NodeSelector              map[string]string                 `json:"nodeSelector,omitempty"`
+	TopologySpreadConstraints []corev1.TopologySpreadConstraint `json:"topologySpreadConstraints,omitempty"`
+}
+
+// RedisPodDisruptionBudget configure a PodDisruptionBudget on the resource (leader/follower)
+// +k8s:deepcopy-gen=true
+type RedisPodDisruptionBudget struct {
+	Enabled        bool   `json:"enabled,omitempty"`
+	MinAvailable   *int32 `json:"minAvailable,omitempty"`
+	MaxUnavailable *int32 `json:"maxUnavailable,omitempty"`
+}
+
+// +k8s:deepcopy-gen=true
+type RedisSentinelConfig struct {
+	AdditionalSentinelConfig *string              `json:"additionalSentinelConfig,omitempty"`
+	RedisReplicationName     string               `json:"redisReplicationName"`
+	RedisReplicationPassword *corev1.EnvVarSource `json:"redisReplicationPassword,omitempty"`
+	// +kubebuilder:default:=myMaster
+	MasterGroupName string `json:"masterGroupName,omitempty"`
+	// +kubebuilder:default:="6379"
+	RedisPort string `json:"redisPort,omitempty"`
+	// +kubebuilder:default:="2"
+	Quorum string `json:"quorum,omitempty"`
+	// +kubebuilder:default:="1"
+	ParallelSyncs string `json:"parallelSyncs,omitempty"`
+	// +kubebuilder:default:="180000"
+	FailoverTimeout string `json:"failoverTimeout,omitempty"`
+	// +kubebuilder:default:="30000"
+	DownAfterMilliseconds string `json:"downAfterMilliseconds,omitempty"`
+	// +kubebuilder:default:="no"
+	ResolveHostnames string `json:"resolveHostnames,omitempty"`
+	// +kubebuilder:default:="no"
+	AnnounceHostnames string `json:"announceHostnames,omitempty"`
+}
+
+// InitContainer for each Redis pods
+// +k8s:deepcopy-gen=true
+type InitContainer struct {
+	Enabled         *bool                        `json:"enabled,omitempty"`
+	Image           string                       `json:"image"`
+	ImagePullPolicy corev1.PullPolicy            `json:"imagePullPolicy,omitempty"`
+	Resources       *corev1.ResourceRequirements `json:"resources,omitempty"`
+	EnvVars         *[]corev1.EnvVar             `json:"env,omitempty"`
+	Command         []string                     `json:"command,omitempty"`
+	Args            []string                     `json:"args,omitempty"`
+	SecurityContext *corev1.SecurityContext      `json:"securityContext,omitempty"`
+}
+
+// +k8s:deepcopy-gen=true
+type ACLConfig struct {
+	Secret *corev1.SecretVolumeSource `json:"secret,omitempty"`
+}

api/common/v1beta2/common_types_test.go

@@ -0,0 +1,86 @@
+package v1beta2
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"k8s.io/utils/ptr"
+)
+
+func TestKubernetesConfig_ShouldCreateAdditionalService(t *testing.T) {
+	tests := []struct {
+		name     string
+		config   *KubernetesConfig
+		expected bool
+	}{
+		{
+			name:     "nil config",
+			config:   nil,
+			expected: true,
+		},
+		{
+			name:     "empty config",
+			config:   &KubernetesConfig{},
+			expected: true,
+		},
+		{
+			name: "nil service",
+			config: &KubernetesConfig{
+				Service: nil,
+			},
+			expected: true,
+		},
+		{
+			name: "nil additional",
+			config: &KubernetesConfig{
+				Service: &ServiceConfig{
+					Additional: nil,
+				},
+			},
+			expected: true,
+		},
+		{
+			name: "nil enabled",
+			config: &KubernetesConfig{
+				Service: &ServiceConfig{
+					Additional: &Service{
+						Enabled: nil,
+					},
+				},
+			},
+			expected: true,
+		},
+		{
+			name: "enabled true",
+			config: &KubernetesConfig{
+				Service: &ServiceConfig{
+					Additional: &Service{
+						Enabled: ptr.To(true),
+					},
+				},
+			},
+			expected: true,
+		},
+		{
+			name: "enabled false",
+			config: &KubernetesConfig{
+				Service: &ServiceConfig{
+					Additional: &Service{
+						Enabled: ptr.To(false),
+					},
+				},
+			},
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.config == nil {
+				assert.True(t, (&KubernetesConfig{}).ShouldCreateAdditionalService())
+				return
+			}
+			assert.Equal(t, tt.expected, tt.config.ShouldCreateAdditionalService())
+		})
+	}
+}

api/common/v1beta2/doc.go

@@ -14,20 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+// Package v1beta2 contains common types used by Redis Operator APIs.
+// These types are shared across different Redis resource types.
+//
+// +groupName=redis.redis.opstreelabs.in
 package v1beta2
-
-import (
-	ctrl "sigs.k8s.io/controller-runtime"
-	logf "sigs.k8s.io/controller-runtime/pkg/log"
-)
-
-// log is for logging in this package.
-var redisclusterlog = logf.Log.WithName("rediscluster-resource")
-
-func (r *RedisCluster) SetupWebhookWithManager(mgr ctrl.Manager) error {
-	return ctrl.NewWebhookManagedBy(mgr).
-		For(r).
-		Complete()
-}
-
-// TODO(user): EDIT THIS FILE!  THIS IS SCAFFOLDING FOR YOU TO OWN!

api/common/v1beta2/zz_generated.deepcopy.go

@@ -1,5 +1,4 @@
 //go:build !ignore_autogenerated
-// +build !ignore_autogenerated
 
 /*
 Copyright 2020 Opstree Solutions.
@@ -19,12 +18,33 @@ limitations under the License.
 
 // Code generated by controller-gen. DO NOT EDIT.
 
-package api
+package v1beta2
 
 import (
+	appsv1 "k8s.io/api/apps/v1"
 	"k8s.io/api/core/v1"
 )
 
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ACLConfig) DeepCopyInto(out *ACLConfig) {
+	*out = *in
+	if in.Secret != nil {
+		in, out := &in.Secret, &out.Secret
+		*out = new(v1.SecretVolumeSource)
+		(*in).DeepCopyInto(*out)
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ACLConfig.
+func (in *ACLConfig) DeepCopy() *ACLConfig {
+	if in == nil {
+		return nil
+	}
+	out := new(ACLConfig)
+	in.DeepCopyInto(out)
+	return out
+}
+
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *AdditionalVolume) DeepCopyInto(out *AdditionalVolume) {
 	*out = *in
@@ -79,6 +99,57 @@ func (in *ExistingPasswordSecret) DeepCopy() *ExistingPasswordSecret {
 	return out
 }
 
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *InitContainer) DeepCopyInto(out *InitContainer) {
+	*out = *in
+	if in.Enabled != nil {
+		in, out := &in.Enabled, &out.Enabled
+		*out = new(bool)
+		**out = **in
+	}
+	if in.Resources != nil {
+		in, out := &in.Resources, &out.Resources
+		*out = new(v1.ResourceRequirements)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.EnvVars != nil {
+		in, out := &in.EnvVars, &out.EnvVars
+		*out = new([]v1.EnvVar)
+		if **in != nil {
+			in, out := *in, *out
+			*out = make([]v1.EnvVar, len(*in))
+			for i := range *in {
+				(*in)[i].DeepCopyInto(&(*out)[i])
+			}
+		}
+	}
+	if in.Command != nil {
+		in, out := &in.Command, &out.Command
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
+	if in.Args != nil {
+		in, out := &in.Args, &out.Args
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
+	if in.SecurityContext != nil {
+		in, out := &in.SecurityContext, &out.SecurityContext
+		*out = new(v1.SecurityContext)
+		(*in).DeepCopyInto(*out)
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new InitContainer.
+func (in *InitContainer) DeepCopy() *InitContainer {
+	if in == nil {
+		return nil
+	}
+	out := new(InitContainer)
+	in.DeepCopyInto(out)
+	return out
+}
+
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *KubernetesConfig) DeepCopyInto(out *KubernetesConfig) {
 	*out = *in
@@ -102,11 +173,26 @@ func (in *KubernetesConfig) DeepCopyInto(out *KubernetesConfig) {
 		}
 	}
 	in.UpdateStrategy.DeepCopyInto(&out.UpdateStrategy)
+	if in.PersistentVolumeClaimRetentionPolicy != nil {
+		in, out := &in.PersistentVolumeClaimRetentionPolicy, &out.PersistentVolumeClaimRetentionPolicy
+		*out = new(appsv1.StatefulSetPersistentVolumeClaimRetentionPolicy)
+		**out = **in
+	}
 	if in.Service != nil {
 		in, out := &in.Service, &out.Service
 		*out = new(ServiceConfig)
 		(*in).DeepCopyInto(*out)
 	}
+	if in.IgnoreAnnotations != nil {
+		in, out := &in.IgnoreAnnotations, &out.IgnoreAnnotations
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
+	if in.MinReadySeconds != nil {
+		in, out := &in.MinReadySeconds, &out.MinReadySeconds
+		*out = new(int32)
+		**out = **in
+	}
 }
 
 // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KubernetesConfig.
@@ -119,24 +205,19 @@ func (in *KubernetesConfig) DeepCopy() *KubernetesConfig {
 	return out
 }
 
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *Probe) DeepCopyInto(out *Probe) {
-	*out = *in
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Probe.
-func (in *Probe) DeepCopy() *Probe {
-	if in == nil {
-		return nil
-	}
-	out := new(Probe)
-	in.DeepCopyInto(out)
-	return out
-}
-
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *RedisConfig) DeepCopyInto(out *RedisConfig) {
 	*out = *in
+	if in.MaxMemoryPercentOfLimit != nil {
+		in, out := &in.MaxMemoryPercentOfLimit, &out.MaxMemoryPercentOfLimit
+		*out = new(int)
+		**out = **in
+	}
+	if in.DynamicConfig != nil {
+		in, out := &in.DynamicConfig, &out.DynamicConfig
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
 	if in.AdditionalRedisConfig != nil {
 		in, out := &in.AdditionalRedisConfig, &out.AdditionalRedisConfig
 		*out = new(string)
@@ -157,6 +238,11 @@ func (in *RedisConfig) DeepCopy() *RedisConfig {
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *RedisExporter) DeepCopyInto(out *RedisExporter) {
 	*out = *in
+	if in.Port != nil {
+		in, out := &in.Port, &out.Port
+		*out = new(int)
+		**out = **in
+	}
 	if in.Resources != nil {
 		in, out := &in.Resources, &out.Resources
 		*out = new(v1.ResourceRequirements)
@@ -173,6 +259,11 @@ func (in *RedisExporter) DeepCopyInto(out *RedisExporter) {
 			}
 		}
 	}
+	if in.SecurityContext != nil {
+		in, out := &in.SecurityContext, &out.SecurityContext
+		*out = new(v1.SecurityContext)
+		(*in).DeepCopyInto(*out)
+	}
 }
 
 // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisExporter.
@@ -210,13 +301,13 @@ func (in *RedisFollower) DeepCopyInto(out *RedisFollower) {
 	}
 	if in.ReadinessProbe != nil {
 		in, out := &in.ReadinessProbe, &out.ReadinessProbe
-		*out = new(Probe)
-		**out = **in
+		*out = new(v1.Probe)
+		(*in).DeepCopyInto(*out)
 	}
 	if in.LivenessProbe != nil {
 		in, out := &in.LivenessProbe, &out.LivenessProbe
-		*out = new(Probe)
-		**out = **in
+		*out = new(v1.Probe)
+		(*in).DeepCopyInto(*out)
 	}
 	if in.Tolerations != nil {
 		in, out := &in.Tolerations, &out.Tolerations
@@ -236,6 +327,13 @@ func (in *RedisFollower) DeepCopyInto(out *RedisFollower) {
 			(*out)[key] = val
 		}
 	}
+	if in.TopologySpreadConstraints != nil {
+		in, out := &in.TopologySpreadConstraints, &out.TopologySpreadConstraints
+		*out = make([]v1.TopologySpreadConstraint, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
 }
 
 // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisFollower.
@@ -273,13 +371,13 @@ func (in *RedisLeader) DeepCopyInto(out *RedisLeader) {
 	}
 	if in.ReadinessProbe != nil {
 		in, out := &in.ReadinessProbe, &out.ReadinessProbe
-		*out = new(Probe)
-		**out = **in
+		*out = new(v1.Probe)
+		(*in).DeepCopyInto(*out)
 	}
 	if in.LivenessProbe != nil {
 		in, out := &in.LivenessProbe, &out.LivenessProbe
-		*out = new(Probe)
-		**out = **in
+		*out = new(v1.Probe)
+		(*in).DeepCopyInto(*out)
 	}
 	if in.Tolerations != nil {
 		in, out := &in.Tolerations, &out.Tolerations
@@ -299,6 +397,13 @@ func (in *RedisLeader) DeepCopyInto(out *RedisLeader) {
 			(*out)[key] = val
 		}
 	}
+	if in.TopologySpreadConstraints != nil {
+		in, out := &in.TopologySpreadConstraints, &out.TopologySpreadConstraints
+		*out = make([]v1.TopologySpreadConstraint, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
 }
 
 // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisLeader.
@@ -344,6 +449,11 @@ func (in *RedisSentinelConfig) DeepCopyInto(out *RedisSentinelConfig) {
 		*out = new(string)
 		**out = **in
 	}
+	if in.RedisReplicationPassword != nil {
+		in, out := &in.RedisReplicationPassword, &out.RedisReplicationPassword
+		*out = new(v1.EnvVarSource)
+		(*in).DeepCopyInto(*out)
+	}
 }
 
 // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisSentinelConfig.
@@ -356,6 +466,38 @@ func (in *RedisSentinelConfig) DeepCopy() *RedisSentinelConfig {
 	return out
 }
 
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Service) DeepCopyInto(out *Service) {
+	*out = *in
+	if in.AdditionalAnnotations != nil {
+		in, out := &in.AdditionalAnnotations, &out.AdditionalAnnotations
+		*out = make(map[string]string, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	if in.IncludeBusPort != nil {
+		in, out := &in.IncludeBusPort, &out.IncludeBusPort
+		*out = new(bool)
+		**out = **in
+	}
+	if in.Enabled != nil {
+		in, out := &in.Enabled, &out.Enabled
+		*out = new(bool)
+		**out = **in
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Service.
+func (in *Service) DeepCopy() *Service {
+	if in == nil {
+		return nil
+	}
+	out := new(Service)
+	in.DeepCopyInto(out)
+	return out
+}
+
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *ServiceConfig) DeepCopyInto(out *ServiceConfig) {
 	*out = *in
@@ -366,6 +508,21 @@ func (in *ServiceConfig) DeepCopyInto(out *ServiceConfig) {
 			(*out)[key] = val
 		}
 	}
+	if in.IncludeBusPort != nil {
+		in, out := &in.IncludeBusPort, &out.IncludeBusPort
+		*out = new(bool)
+		**out = **in
+	}
+	if in.Headless != nil {
+		in, out := &in.Headless, &out.Headless
+		*out = new(Service)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Additional != nil {
+		in, out := &in.Additional, &out.Additional
+		*out = new(Service)
+		(*in).DeepCopyInto(*out)
+	}
 }
 
 // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServiceConfig.
@@ -397,6 +554,36 @@ func (in *Sidecar) DeepCopyInto(out *Sidecar) {
 			}
 		}
 	}
+	if in.Volumes != nil {
+		in, out := &in.Volumes, &out.Volumes
+		*out = new([]v1.VolumeMount)
+		if **in != nil {
+			in, out := *in, *out
+			*out = make([]v1.VolumeMount, len(*in))
+			for i := range *in {
+				(*in)[i].DeepCopyInto(&(*out)[i])
+			}
+		}
+	}
+	if in.Command != nil {
+		in, out := &in.Command, &out.Command
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
+	if in.Ports != nil {
+		in, out := &in.Ports, &out.Ports
+		*out = new([]v1.ContainerPort)
+		if **in != nil {
+			in, out := *in, *out
+			*out = make([]v1.ContainerPort, len(*in))
+			copy(*out, *in)
+		}
+	}
+	if in.SecurityContext != nil {
+		in, out := &in.SecurityContext, &out.SecurityContext
+		*out = new(v1.SecurityContext)
+		(*in).DeepCopyInto(*out)
+	}
 }
 
 // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Sidecar.

api/common_types.go

@@ -1,159 +0,0 @@
-package api
-
-import (
-	appsv1 "k8s.io/api/apps/v1"
-	corev1 "k8s.io/api/core/v1"
-)
-
-// KubernetesConfig will be the JSON struct for Basic Redis Config
-// +k8s:deepcopy-gen=true
-type KubernetesConfig struct {
-	Image                  string                           `json:"image"`
-	ImagePullPolicy        corev1.PullPolicy                `json:"imagePullPolicy,omitempty"`
-	Resources              *corev1.ResourceRequirements     `json:"resources,omitempty"`
-	ExistingPasswordSecret *ExistingPasswordSecret          `json:"redisSecret,omitempty"`
-	ImagePullSecrets       *[]corev1.LocalObjectReference   `json:"imagePullSecrets,omitempty"`
-	UpdateStrategy         appsv1.StatefulSetUpdateStrategy `json:"updateStrategy,omitempty"`
-	Service                *ServiceConfig                   `json:"service,omitempty"`
-}
-
-// ServiceConfig define the type of service to be created and its annotations
-// +k8s:deepcopy-gen=true
-type ServiceConfig struct {
-	// +kubebuilder:validation:Enum=LoadBalancer;NodePort;ClusterIP
-	ServiceType        string            `json:"serviceType,omitempty"`
-	ServiceAnnotations map[string]string `json:"annotations,omitempty"`
-}
-
-// ExistingPasswordSecret is the struct to access the existing secret
-// +k8s:deepcopy-gen=true
-type ExistingPasswordSecret struct {
-	Name *string `json:"name,omitempty"`
-	Key  *string `json:"key,omitempty"`
-}
-
-// RedisExporter interface will have the information for redis exporter related stuff
-// +k8s:deepcopy-gen=true
-type RedisExporter struct {
-	Enabled         bool                         `json:"enabled,omitempty"`
-	Image           string                       `json:"image"`
-	Resources       *corev1.ResourceRequirements `json:"resources,omitempty"`
-	ImagePullPolicy corev1.PullPolicy            `json:"imagePullPolicy,omitempty"`
-	EnvVars         *[]corev1.EnvVar             `json:"env,omitempty"`
-}
-
-// RedisConfig defines the external configuration of Redis
-// +k8s:deepcopy-gen=true
-type RedisConfig struct {
-	AdditionalRedisConfig *string `json:"additionalRedisConfig,omitempty"`
-}
-
-// Storage is the inteface to add pvc and pv support in redis
-// +k8s:deepcopy-gen=true
-type Storage struct {
-	VolumeClaimTemplate corev1.PersistentVolumeClaim `json:"volumeClaimTemplate,omitempty"`
-	VolumeMount         AdditionalVolume             `json:"volumeMount,omitempty"`
-}
-
-// Additional Volume is provided by user that is mounted on the pods
-// +k8s:deepcopy-gen=true
-type AdditionalVolume struct {
-	Volume    []corev1.Volume      `json:"volume,omitempty"`
-	MountPath []corev1.VolumeMount `json:"mountPath,omitempty"`
-}
-
-// TLS Configuration for redis instances
-// +k8s:deepcopy-gen=true
-type TLSConfig struct {
-	CaKeyFile   string `json:"ca,omitempty"`
-	CertKeyFile string `json:"cert,omitempty"`
-	KeyFile     string `json:"key,omitempty"`
-	// Reference to secret which contains the certificates
-	Secret corev1.SecretVolumeSource `json:"secret"`
-}
-
-// Probe is a interface for ReadinessProbe and LivenessProbe
-// +k8s:deepcopy-gen=true
-type Probe struct {
-	// +kubebuilder:validation:Minimum=1
-	// +kubebuilder:default=1
-	InitialDelaySeconds int32 `json:"initialDelaySeconds,omitempty" protobuf:"varint,2,opt,name=initialDelaySeconds"`
-	// +kubebuilder:validation:Minimum=1
-	// +kubebuilder:default=1
-	TimeoutSeconds int32 `json:"timeoutSeconds,omitempty" protobuf:"varint,3,opt,name=timeoutSeconds"`
-	// +kubebuilder:validation:Minimum=1
-	// +kubebuilder:default=10
-	PeriodSeconds int32 `json:"periodSeconds,omitempty" protobuf:"varint,4,opt,name=periodSeconds"`
-	// +kubebuilder:validation:Minimum=1
-	// +kubebuilder:default=1
-	SuccessThreshold int32 `json:"successThreshold,omitempty" protobuf:"varint,5,opt,name=successThreshold"`
-	// +kubebuilder:validation:Minimum=1
-	// +kubebuilder:default=3
-	FailureThreshold int32 `json:"failureThreshold,omitempty" protobuf:"varint,6,opt,name=failureThreshold"`
-}
-
-// Sidecar for each Redis pods
-// +k8s:deepcopy-gen=true
-type Sidecar struct {
-	Name            string                       `json:"name"`
-	Image           string                       `json:"image"`
-	ImagePullPolicy corev1.PullPolicy            `json:"imagePullPolicy,omitempty"`
-	Resources       *corev1.ResourceRequirements `json:"resources,omitempty"`
-	EnvVars         *[]corev1.EnvVar             `json:"env,omitempty"`
-}
-
-// RedisLeader interface will have the redis leader configuration
-// +k8s:deepcopy-gen=true
-type RedisLeader struct {
-	Replicas            *int32                    `json:"replicas,omitempty"`
-	RedisConfig         *RedisConfig              `json:"redisConfig,omitempty"`
-	Affinity            *corev1.Affinity          `json:"affinity,omitempty"`
-	PodDisruptionBudget *RedisPodDisruptionBudget `json:"pdb,omitempty"`
-	// +kubebuilder:default:={initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}
-	ReadinessProbe *Probe `json:"readinessProbe,omitempty" protobuf:"bytes,11,opt,name=readinessProbe"`
-	// +kubebuilder:default:={initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}
-	LivenessProbe *Probe               `json:"livenessProbe,omitempty" protobuf:"bytes,11,opt,name=livenessProbe"`
-	Tolerations   *[]corev1.Toleration `json:"tolerations,omitempty"`
-	NodeSelector  map[string]string    `json:"nodeSelector,omitempty"`
-}
-
-// RedisFollower interface will have the redis follower configuration
-// +k8s:deepcopy-gen=true
-type RedisFollower struct {
-	Replicas            *int32                    `json:"replicas,omitempty"`
-	RedisConfig         *RedisConfig              `json:"redisConfig,omitempty"`
-	Affinity            *corev1.Affinity          `json:"affinity,omitempty"`
-	PodDisruptionBudget *RedisPodDisruptionBudget `json:"pdb,omitempty"`
-	// +kubebuilder:default:={initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}
-	ReadinessProbe *Probe `json:"readinessProbe,omitempty" protobuf:"bytes,11,opt,name=readinessProbe"`
-	// +kubebuilder:default:={initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}
-	LivenessProbe *Probe               `json:"livenessProbe,omitempty" protobuf:"bytes,11,opt,name=livenessProbe"`
-	Tolerations   *[]corev1.Toleration `json:"tolerations,omitempty"`
-	NodeSelector  map[string]string    `json:"nodeSelector,omitempty"`
-}
-
-// RedisPodDisruptionBudget configure a PodDisruptionBudget on the resource (leader/follower)
-// +k8s:deepcopy-gen=true
-type RedisPodDisruptionBudget struct {
-	Enabled        bool   `json:"enabled,omitempty"`
-	MinAvailable   *int32 `json:"minAvailable,omitempty"`
-	MaxUnavailable *int32 `json:"maxUnavailable,omitempty"`
-}
-
-// +k8s:deepcopy-gen=true
-type RedisSentinelConfig struct {
-	AdditionalSentinelConfig *string `json:"additionalSentinelConfig,omitempty"`
-	RedisReplicationName     string  `json:"redisReplicationName"`
-	// +kubebuilder:default:=myMaster
-	MasterGroupName string `json:"masterGroupName,omitempty"`
-	// +kubebuilder:default:="6379"
-	RedisPort string `json:"redisPort,omitempty"`
-	// +kubebuilder:default:="2"
-	Quorum string `json:"quorum,omitempty"`
-	// +kubebuilder:default:="1"
-	ParallelSyncs string `json:"parallelSyncs,omitempty"`
-	// +kubebuilder:default:="180000"
-	FailoverTimeout string `json:"failoverTimeout,omitempty"`
-	// +kubebuilder:default:="30000"
-	DownAfterMilliseconds string `json:"downAfterMilliseconds,omitempty"`
-}

api/rbac.go

@@ -5,7 +5,7 @@ package api
 // +kubebuilder:rbac:groups=apiextensions.k8s.io,resources=customresourcedefinitions,verbs=get;list;watch
 // +kubebuilder:rbac:groups=redis.redis.opstreelabs.in,resources=redis/finalizers;rediscluster/finalizers;redisclusters/finalizers;redissentinel/finalizers;redissentinels/finalizers;redisreplication/finalizers;redisreplications/finalizers,verbs=update
 // +kubebuilder:rbac:groups=redis.redis.opstreelabs.in,resources=redis/status;rediscluster/status;redisclusters/status;redissentinel/status;redissentinels/status;redisreplication/status;redisreplications/status,verbs=get;patch;update
-// +kubebuilder:rbac:groups=,resources=secrets;pods/exec;pods;services;configmaps;events;persistentvolumeclaims;namespaces,verbs=create;delete;get;list;patch;update;watch
+// +kubebuilder:rbac:groups="",resources=secrets;pods/exec;pods;services;configmaps;events;persistentvolumeclaims;namespaces,verbs=create;delete;get;list;patch;update;watch
 // +kubebuilder:rbac:groups=apps,resources=statefulsets,verbs=create;delete;get;list;patch;update;watch
 // +kubebuilder:rbac:groups=coordination.k8s.io,resources=leases,verbs=create;delete;get;list;patch;update;watch
 // +kubebuilder:rbac:groups=policy,resources=poddisruptionbudgets,verbs=create;delete;get;list;patch;update;watch

api/redis/v1beta2/redis_types.go

@@ -0,0 +1,80 @@
+/*
+Copyright 2020 Opstree Solutions.
+
+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.
+*/
+
+package v1beta2
+
+import (
+	common "github.com/OT-CONTAINER-KIT/redis-operator/api/common/v1beta2"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// EDIT THIS FILE!  THIS IS SCAFFOLDING FOR YOU TO OWN!
+// NOTE: json tags are required.  Any new fields you add must have json tags for the fields to be serialized.
+
+// RedisSpec defines the desired state of Redis
+type RedisSpec struct {
+	KubernetesConfig              common.KubernetesConfig    `json:"kubernetesConfig"`
+	RedisExporter                 *common.RedisExporter      `json:"redisExporter,omitempty"`
+	RedisConfig                   *common.RedisConfig        `json:"redisConfig,omitempty"`
+	Storage                       *common.Storage            `json:"storage,omitempty"`
+	NodeSelector                  map[string]string          `json:"nodeSelector,omitempty"`
+	PodSecurityContext            *corev1.PodSecurityContext `json:"podSecurityContext,omitempty"`
+	SecurityContext               *corev1.SecurityContext    `json:"securityContext,omitempty"`
+	PriorityClassName             string                     `json:"priorityClassName,omitempty"`
+	Affinity                      *corev1.Affinity           `json:"affinity,omitempty"`
+	Tolerations                   *[]corev1.Toleration       `json:"tolerations,omitempty"`
+	TLS                           *common.TLSConfig          `json:"TLS,omitempty"`
+	ACL                           *common.ACLConfig          `json:"acl,omitempty"`
+	ReadinessProbe                *corev1.Probe              `json:"readinessProbe,omitempty" protobuf:"bytes,11,opt,name=readinessProbe"`
+	LivenessProbe                 *corev1.Probe              `json:"livenessProbe,omitempty" protobuf:"bytes,12,opt,name=livenessProbe"`
+	InitContainer                 *common.InitContainer      `json:"initContainer,omitempty"`
+	Sidecars                      *[]common.Sidecar          `json:"sidecars,omitempty"`
+	ServiceAccountName            *string                    `json:"serviceAccountName,omitempty"`
+	TerminationGracePeriodSeconds *int64                     `json:"terminationGracePeriodSeconds,omitempty" protobuf:"varint,4,opt,name=terminationGracePeriodSeconds"`
+	EnvVars                       *[]corev1.EnvVar           `json:"env,omitempty"`
+	HostPort                      *int                       `json:"hostPort,omitempty"`
+}
+
+// RedisStatus defines the observed state of Redis
+type RedisStatus struct{}
+
+// +kubebuilder:object:root=true
+// +kubebuilder:subresource:status
+// +kubebuilder:storageversion
+
+// Redis is the Schema for the redis API
+type Redis struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	Spec   RedisSpec   `json:"spec"`
+	Status RedisStatus `json:"status,omitempty"`
+}
+
+// +kubebuilder:object:root=true
+
+// RedisList contains a list of Redis
+type RedisList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []Redis `json:"items"`
+}
+
+//nolint:gochecknoinits
+func init() {
+	SchemeBuilder.Register(&Redis{}, &RedisList{})
+}

api/redis/v1beta2/redis_webhook.go

@@ -18,12 +18,8 @@ package v1beta2
 
 import (
 	ctrl "sigs.k8s.io/controller-runtime"
-	logf "sigs.k8s.io/controller-runtime/pkg/log"
 )
 
-// log is for logging in this package.
-var redislog = logf.Log.WithName("redis-resource")
-
 func (r *Redis) SetupWebhookWithManager(mgr ctrl.Manager) error {
 	return ctrl.NewWebhookManagedBy(mgr).
 		For(r).

api/redis/v1beta2/zz_generated.deepcopy.go

@@ -0,0 +1,227 @@
+//go:build !ignore_autogenerated
+
+/*
+Copyright 2020 Opstree Solutions.
+
+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 controller-gen. DO NOT EDIT.
+
+package v1beta2
+
+import (
+	commonv1beta2 "github.com/OT-CONTAINER-KIT/redis-operator/api/common/v1beta2"
+	"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 *Redis) DeepCopyInto(out *Redis) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	in.Spec.DeepCopyInto(&out.Spec)
+	out.Status = in.Status
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Redis.
+func (in *Redis) DeepCopy() *Redis {
+	if in == nil {
+		return nil
+	}
+	out := new(Redis)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *Redis) 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 *RedisList) DeepCopyInto(out *RedisList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ListMeta.DeepCopyInto(&out.ListMeta)
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]Redis, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisList.
+func (in *RedisList) DeepCopy() *RedisList {
+	if in == nil {
+		return nil
+	}
+	out := new(RedisList)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *RedisList) 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 *RedisSpec) DeepCopyInto(out *RedisSpec) {
+	*out = *in
+	in.KubernetesConfig.DeepCopyInto(&out.KubernetesConfig)
+	if in.RedisExporter != nil {
+		in, out := &in.RedisExporter, &out.RedisExporter
+		*out = new(commonv1beta2.RedisExporter)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.RedisConfig != nil {
+		in, out := &in.RedisConfig, &out.RedisConfig
+		*out = new(commonv1beta2.RedisConfig)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Storage != nil {
+		in, out := &in.Storage, &out.Storage
+		*out = new(commonv1beta2.Storage)
+		(*in).DeepCopyInto(*out)
+	}
+	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
+		}
+	}
+	if in.PodSecurityContext != nil {
+		in, out := &in.PodSecurityContext, &out.PodSecurityContext
+		*out = new(v1.PodSecurityContext)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.SecurityContext != nil {
+		in, out := &in.SecurityContext, &out.SecurityContext
+		*out = new(v1.SecurityContext)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Affinity != nil {
+		in, out := &in.Affinity, &out.Affinity
+		*out = new(v1.Affinity)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Tolerations != nil {
+		in, out := &in.Tolerations, &out.Tolerations
+		*out = new([]v1.Toleration)
+		if **in != nil {
+			in, out := *in, *out
+			*out = make([]v1.Toleration, len(*in))
+			for i := range *in {
+				(*in)[i].DeepCopyInto(&(*out)[i])
+			}
+		}
+	}
+	if in.TLS != nil {
+		in, out := &in.TLS, &out.TLS
+		*out = new(commonv1beta2.TLSConfig)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.ACL != nil {
+		in, out := &in.ACL, &out.ACL
+		*out = new(commonv1beta2.ACLConfig)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.ReadinessProbe != nil {
+		in, out := &in.ReadinessProbe, &out.ReadinessProbe
+		*out = new(v1.Probe)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.LivenessProbe != nil {
+		in, out := &in.LivenessProbe, &out.LivenessProbe
+		*out = new(v1.Probe)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.InitContainer != nil {
+		in, out := &in.InitContainer, &out.InitContainer
+		*out = new(commonv1beta2.InitContainer)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Sidecars != nil {
+		in, out := &in.Sidecars, &out.Sidecars
+		*out = new([]commonv1beta2.Sidecar)
+		if **in != nil {
+			in, out := *in, *out
+			*out = make([]commonv1beta2.Sidecar, len(*in))
+			for i := range *in {
+				(*in)[i].DeepCopyInto(&(*out)[i])
+			}
+		}
+	}
+	if in.ServiceAccountName != nil {
+		in, out := &in.ServiceAccountName, &out.ServiceAccountName
+		*out = new(string)
+		**out = **in
+	}
+	if in.TerminationGracePeriodSeconds != nil {
+		in, out := &in.TerminationGracePeriodSeconds, &out.TerminationGracePeriodSeconds
+		*out = new(int64)
+		**out = **in
+	}
+	if in.EnvVars != nil {
+		in, out := &in.EnvVars, &out.EnvVars
+		*out = new([]v1.EnvVar)
+		if **in != nil {
+			in, out := *in, *out
+			*out = make([]v1.EnvVar, len(*in))
+			for i := range *in {
+				(*in)[i].DeepCopyInto(&(*out)[i])
+			}
+		}
+	}
+	if in.HostPort != nil {
+		in, out := &in.HostPort, &out.HostPort
+		*out = new(int)
+		**out = **in
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisSpec.
+func (in *RedisSpec) DeepCopy() *RedisSpec {
+	if in == nil {
+		return nil
+	}
+	out := new(RedisSpec)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *RedisStatus) DeepCopyInto(out *RedisStatus) {
+	*out = *in
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisStatus.
+func (in *RedisStatus) DeepCopy() *RedisStatus {
+	if in == nil {
+		return nil
+	}
+	out := new(RedisStatus)
+	in.DeepCopyInto(out)
+	return out
+}

api/rediscluster/v1beta2/groupversion_info.go

@@ -14,10 +14,10 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Package v1beta1 contains API Schema definitions for the redis v1beta1 API group
+// Package v1beta2 contains API Schema definitions for the redis v1beta2 API group
 // +kubebuilder:object:generate=true
 // +groupName=redis.redis.opstreelabs.in
-package v1beta1
+package v1beta2
 
 import (
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -26,7 +26,7 @@ import (
 
 var (
 	// GroupVersion is group version used to register these objects
-	GroupVersion = schema.GroupVersion{Group: "redis.redis.opstreelabs.in", Version: "v1beta1"}
+	GroupVersion = schema.GroupVersion{Group: "redis.redis.opstreelabs.in", Version: "v1beta2"}
 
 	// SchemeBuilder is used to add go types to the GroupVersionKind scheme
 	SchemeBuilder = &scheme.Builder{GroupVersion: GroupVersion}

api/rediscluster/v1beta2/rediscluster_default.go

@@ -0,0 +1,13 @@
+package v1beta2
+
+import "k8s.io/utils/ptr"
+
+// SetDefault sets default values for the RedisCluster object.
+func (r *RedisCluster) SetDefault() {
+	if r.Spec.Port == nil {
+		r.Spec.Port = ptr.To(6379)
+	}
+	if r.Spec.RedisExporter != nil && r.Spec.RedisExporter.Port == nil {
+		r.Spec.RedisExporter.Port = ptr.To(9121)
+	}
+}

api/rediscluster/v1beta2/rediscluster_types.go

@@ -0,0 +1,176 @@
+/*
+Copyright 2020 Opstree Solutions.
+
+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.
+*/
+
+package v1beta2
+
+import (
+	common "github.com/OT-CONTAINER-KIT/redis-operator/api/common/v1beta2"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// RedisClusterSpec defines the desired state of RedisCluster
+type RedisClusterSpec struct {
+	// ClusterSize defines the default number of replicas for both leader and follower when not explicitly set
+	ClusterSize      *int32                  `json:"clusterSize"`
+	KubernetesConfig common.KubernetesConfig `json:"kubernetesConfig"`
+	HostNetwork      bool                    `json:"hostNetwork,omitempty"`
+	// +kubebuilder:default:=6379
+	Port *int `json:"port,omitempty"`
+	// +kubebuilder:default:=v7
+	ClusterVersion     *string                      `json:"clusterVersion,omitempty"`
+	RedisConfig        *common.RedisConfig          `json:"redisConfig,omitempty"`
+	RedisLeader        RedisLeader                  `json:"redisLeader,omitempty"`
+	RedisFollower      RedisFollower                `json:"redisFollower,omitempty"`
+	RedisExporter      *common.RedisExporter        `json:"redisExporter,omitempty"`
+	Storage            *ClusterStorage              `json:"storage,omitempty"`
+	PodSecurityContext *corev1.PodSecurityContext   `json:"podSecurityContext,omitempty"`
+	PriorityClassName  string                       `json:"priorityClassName,omitempty"`
+	Resources          *corev1.ResourceRequirements `json:"resources,omitempty"`
+	TLS                *common.TLSConfig            `json:"TLS,omitempty"`
+	ACL                *common.ACLConfig            `json:"acl,omitempty"`
+	InitContainer      *common.InitContainer        `json:"initContainer,omitempty"`
+	Sidecars           *[]common.Sidecar            `json:"sidecars,omitempty"`
+	ServiceAccountName *string                      `json:"serviceAccountName,omitempty"`
+	PersistenceEnabled *bool                        `json:"persistenceEnabled,omitempty"`
+	EnvVars            *[]corev1.EnvVar             `json:"env,omitempty"`
+	HostPort           *int                         `json:"hostPort,omitempty"`
+}
+
+// Node-conf needs to be added only in redis cluster
+type ClusterStorage struct {
+	// +kubebuilder:default=false
+	NodeConfVolume              bool                         `json:"nodeConfVolume,omitempty"`
+	NodeConfVolumeClaimTemplate corev1.PersistentVolumeClaim `json:"nodeConfVolumeClaimTemplate,omitempty"`
+	common.Storage              `json:",inline"`
+}
+
+func (cr *RedisClusterSpec) GetReplicaCounts(t string) int32 {
+	replica := cr.ClusterSize
+	if t == "leader" && cr.RedisLeader.Replicas != nil {
+		replica = cr.RedisLeader.Replicas
+	} else if t == "follower" && cr.RedisFollower.Replicas != nil {
+		replica = cr.RedisFollower.Replicas
+	}
+	return *replica
+}
+
+// GetRedisLeaderResources returns the resources for the redis leader, if not set, it will return the default resources
+func (cr *RedisClusterSpec) GetRedisLeaderResources() *corev1.ResourceRequirements {
+	if cr.RedisLeader.Resources != nil {
+		return cr.RedisLeader.Resources
+	}
+
+	return cr.KubernetesConfig.Resources
+}
+
+// GetRedisDynamicConfig returns Redis dynamic configuration parameters.
+// Priority: top-level config > leader config > follower config
+func (cr *RedisClusterSpec) GetRedisDynamicConfig() []string {
+	// Use top-level configuration if available
+	if cr.RedisConfig != nil && len(cr.RedisConfig.DynamicConfig) > 0 {
+		return cr.RedisConfig.DynamicConfig
+	}
+	// Return empty slice if no configuration is found
+	return []string{}
+}
+
+// GetRedisFollowerResources returns the resources for the redis follower, if not set, it will return the default resources
+func (cr *RedisClusterSpec) GetRedisFollowerResources() *corev1.ResourceRequirements {
+	if cr.RedisFollower.Resources != nil {
+		return cr.RedisFollower.Resources
+	}
+
+	return cr.KubernetesConfig.Resources
+}
+
+// RedisLeader interface will have the redis leader configuration
+type RedisLeader struct {
+	common.RedisLeader            `json:",inline"`
+	SecurityContext               *corev1.SecurityContext      `json:"securityContext,omitempty"`
+	TerminationGracePeriodSeconds *int64                       `json:"terminationGracePeriodSeconds,omitempty" protobuf:"varint,4,opt,name=terminationGracePeriodSeconds"`
+	Resources                     *corev1.ResourceRequirements `json:"resources,omitempty"`
+}
+
+// RedisFollower interface will have the redis follower configuration
+type RedisFollower struct {
+	common.RedisFollower          `json:",inline"`
+	SecurityContext               *corev1.SecurityContext      `json:"securityContext,omitempty"`
+	TerminationGracePeriodSeconds *int64                       `json:"terminationGracePeriodSeconds,omitempty" protobuf:"varint,4,opt,name=terminationGracePeriodSeconds"`
+	Resources                     *corev1.ResourceRequirements `json:"resources,omitempty"`
+}
+
+// RedisClusterStatus defines the observed state of RedisCluster
+// +kubebuilder:subresource:status
+type RedisClusterStatus struct {
+	State  RedisClusterState `json:"state,omitempty"`
+	Reason string            `json:"reason,omitempty"`
+	// +kubebuilder:default=0
+	ReadyLeaderReplicas int32 `json:"readyLeaderReplicas,omitempty"`
+	// +kubebuilder:default=0
+	ReadyFollowerReplicas int32 `json:"readyFollowerReplicas,omitempty"`
+}
+
+type RedisClusterState string
+
+const (
+	InitializingClusterLeaderReason   string = "RedisCluster is initializing leaders"
+	InitializingClusterFollowerReason string = "RedisCluster is initializing followers"
+	BootstrapClusterReason            string = "RedisCluster is bootstrapping"
+	ReadyClusterReason                string = "RedisCluster is ready"
+)
+
+// Status Field of the Redis Cluster
+const (
+	RedisClusterInitializing RedisClusterState = "Initializing"
+	RedisClusterBootstrap    RedisClusterState = "Bootstrap"
+	// RedisClusterReady means the RedisCluster is ready for use, we use redis-cli --cluster check 127.0.0.1:6379 to check the cluster status
+	RedisClusterReady  RedisClusterState = "Ready"
+	RedisClusterFailed RedisClusterState = "Failed"
+)
+
+// +kubebuilder:object:root=true
+// +kubebuilder:subresource:status
+// +kubebuilder:storageversion
+// +kubebuilder:printcolumn:name="ClusterSize",type=integer,JSONPath=`.spec.clusterSize`,description=Current cluster node count
+// +kubebuilder:printcolumn:name="ReadyLeaderReplicas",type="integer",JSONPath=".status.readyLeaderReplicas",description="Number of ready leader replicas"
+// +kubebuilder:printcolumn:name="ReadyFollowerReplicas",type="integer",JSONPath=".status.readyFollowerReplicas",description="Number of ready follower replicas"
+// +kubebuilder:printcolumn:name="State",type="string",JSONPath=".status.state",description="The current state of the Redis Cluster",priority=1
+// +kubebuilder:printcolumn:name="Age",type=date,JSONPath=`.metadata.creationTimestamp`,description="Age of Cluster",priority=1
+// +kubebuilder:printcolumn:name="Reason",type="string",JSONPath=".status.reason",description="The reason for the current state",priority=1
+
+// RedisCluster is the Schema for the redisclusters API
+type RedisCluster struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	Spec   RedisClusterSpec   `json:"spec"`
+	Status RedisClusterStatus `json:"status,omitempty"`
+}
+
+//+kubebuilder:object:root=true
+
+// RedisClusterList contains a list of RedisCluster
+type RedisClusterList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []RedisCluster `json:"items"`
+}
+
+//nolint:gochecknoinits
+func init() {
+	SchemeBuilder.Register(&RedisCluster{}, &RedisClusterList{})
+}

api/rediscluster/v1beta2/rediscluster_webhook.go

@@ -0,0 +1,100 @@
+/*
+Copyright 2020 Opstree Solutions.
+
+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.
+*/
+
+package v1beta2
+
+import (
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/validation/field"
+	ctrl "sigs.k8s.io/controller-runtime"
+	logf "sigs.k8s.io/controller-runtime/pkg/log"
+	"sigs.k8s.io/controller-runtime/pkg/webhook"
+	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
+)
+
+const (
+	webhookPath = "/validate-redis-redis-opstreelabs-in-v1beta2-rediscluster"
+)
+
+// log is for logging in this package.
+var redisclusterlog = logf.Log.WithName("rediscluster-v1beta2-validation")
+
+// +kubebuilder:webhook:path=/validate-redis-redis-opstreelabs-in-v1beta2-rediscluster,mutating=false,failurePolicy=fail,sideEffects=None,groups=redis.redis.opstreelabs.in,resources=redisclusters,verbs=create;update,versions=v1beta2,name=validate-rediscluster.redis.opstreelabs.in,admissionReviewVersions=v1
+
+// SetupWebhookWithManager will setup the manager
+func (r *RedisCluster) SetupWebhookWithManager(mgr ctrl.Manager) error {
+	return ctrl.NewWebhookManagedBy(mgr).
+		For(r).
+		Complete()
+}
+
+var _ webhook.Validator = &RedisCluster{}
+
+// ValidateCreate implements webhook.Validator so a webhook will be registered for the type
+func (r *RedisCluster) ValidateCreate() (admission.Warnings, error) {
+	redisclusterlog.Info("validate create", "name", r.Name)
+
+	return r.validate(nil)
+}
+
+// ValidateUpdate implements webhook.Validator so a webhook will be registered for the type
+func (r *RedisCluster) ValidateUpdate(old runtime.Object) (admission.Warnings, error) {
+	redisclusterlog.Info("validate update", "name", r.Name)
+
+	return r.validate(old.(*RedisCluster))
+}
+
+// ValidateDelete implements webhook.Validator so a webhook will be registered for the type
+func (r *RedisCluster) ValidateDelete() (admission.Warnings, error) {
+	redisclusterlog.Info("validate delete", "name", r.Name)
+
+	return nil, nil
+}
+
+// validate validates the Redis Cluster CR
+func (r *RedisCluster) validate(_ *RedisCluster) (admission.Warnings, error) {
+	var errors field.ErrorList
+	var warnings admission.Warnings
+
+	if r.Spec.ClusterSize == nil {
+		return warnings, nil
+	}
+
+	// Check if the Size is at least 3 for proper cluster operation
+	if *r.Spec.ClusterSize < 3 {
+		errors = append(errors, field.Invalid(
+			field.NewPath("spec").Child("clusterSize"),
+			*r.Spec.ClusterSize,
+			"Redis cluster must have at least 3 shards",
+		))
+	}
+
+	if len(errors) == 0 {
+		return nil, nil
+	}
+
+	return nil, apierrors.NewInvalid(
+		schema.GroupKind{Group: "redis.redis.opstreelabs.in", Kind: "RedisCluster"},
+		r.Name,
+		errors,
+	)
+}
+
+func (r *RedisCluster) WebhookPath() string {
+	return webhookPath
+}

api/rediscluster/v1beta2/rediscluster_webhook_test.go

@@ -0,0 +1,68 @@
+package v1beta2_test
+
+import (
+	"encoding/json"
+	"fmt"
+	"testing"
+
+	v1beta2 "github.com/OT-CONTAINER-KIT/redis-operator/api/rediscluster/v1beta2"
+	"github.com/OT-CONTAINER-KIT/redis-operator/internal/testutil/webhook"
+	"github.com/stretchr/testify/require"
+	admissionv1beta1 "k8s.io/api/admission/v1beta1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/utils/ptr"
+)
+
+func TestRedisClusterWebhook(t *testing.T) {
+	cases := []webhook.ValidationWebhookTestCase{
+		{
+			Name:      "success-create-v1beta2-rediscluster-validate-clusterSize-3",
+			Operation: admissionv1beta1.Create,
+			Object: func(t *testing.T, uid string) []byte {
+				t.Helper()
+				cluster := mkRedisCluster(uid)
+				cluster.Spec.ClusterSize = ptr.To(int32(3))
+				return marshal(t, cluster)
+			},
+			Check: webhook.ValidationWebhookSucceeded,
+		},
+		{
+			Name:      "failed-create-v1beta2-rediscluster-validate-clusterSize-2",
+			Operation: admissionv1beta1.Create,
+			Object: func(t *testing.T, uid string) []byte {
+				t.Helper()
+				cluster := mkRedisCluster(uid)
+				cluster.Spec.ClusterSize = ptr.To(int32(2))
+				return marshal(t, cluster)
+			},
+			Check: webhook.ValidationWebhookFailed("Redis cluster must have at least 3 shards"),
+		},
+	}
+
+	gvk := metav1.GroupVersionKind{
+		Group:   "redis.redis.opstreelabs.in",
+		Version: "v1beta2",
+		Kind:    "RedisCluster",
+	}
+
+	cluster := &v1beta2.RedisCluster{}
+	webhook.RunValidationWebhookTests(t, gvk, cluster, cases...)
+}
+
+func mkRedisCluster(uid string) *v1beta2.RedisCluster {
+	return &v1beta2.RedisCluster{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: fmt.Sprintf("test-%s", uid),
+			UID:  types.UID(fmt.Sprintf("test-%s", uid)),
+		},
+		Spec: v1beta2.RedisClusterSpec{},
+	}
+}
+
+func marshal(t *testing.T, obj interface{}) []byte {
+	t.Helper()
+	bytes, err := json.Marshal(obj)
+	require.NoError(t, err)
+	return bytes
+}

api/rediscluster/v1beta2/zz_generated.deepcopy.go

@@ -0,0 +1,290 @@
+//go:build !ignore_autogenerated
+
+/*
+Copyright 2020 Opstree Solutions.
+
+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 controller-gen. DO NOT EDIT.
+
+package v1beta2
+
+import (
+	commonv1beta2 "github.com/OT-CONTAINER-KIT/redis-operator/api/common/v1beta2"
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+)
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ClusterStorage) DeepCopyInto(out *ClusterStorage) {
+	*out = *in
+	in.NodeConfVolumeClaimTemplate.DeepCopyInto(&out.NodeConfVolumeClaimTemplate)
+	in.Storage.DeepCopyInto(&out.Storage)
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterStorage.
+func (in *ClusterStorage) DeepCopy() *ClusterStorage {
+	if in == nil {
+		return nil
+	}
+	out := new(ClusterStorage)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *RedisCluster) DeepCopyInto(out *RedisCluster) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	in.Spec.DeepCopyInto(&out.Spec)
+	out.Status = in.Status
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisCluster.
+func (in *RedisCluster) DeepCopy() *RedisCluster {
+	if in == nil {
+		return nil
+	}
+	out := new(RedisCluster)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *RedisCluster) 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 *RedisClusterList) DeepCopyInto(out *RedisClusterList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ListMeta.DeepCopyInto(&out.ListMeta)
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]RedisCluster, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisClusterList.
+func (in *RedisClusterList) DeepCopy() *RedisClusterList {
+	if in == nil {
+		return nil
+	}
+	out := new(RedisClusterList)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *RedisClusterList) 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 *RedisClusterSpec) DeepCopyInto(out *RedisClusterSpec) {
+	*out = *in
+	if in.ClusterSize != nil {
+		in, out := &in.ClusterSize, &out.ClusterSize
+		*out = new(int32)
+		**out = **in
+	}
+	in.KubernetesConfig.DeepCopyInto(&out.KubernetesConfig)
+	if in.Port != nil {
+		in, out := &in.Port, &out.Port
+		*out = new(int)
+		**out = **in
+	}
+	if in.ClusterVersion != nil {
+		in, out := &in.ClusterVersion, &out.ClusterVersion
+		*out = new(string)
+		**out = **in
+	}
+	if in.RedisConfig != nil {
+		in, out := &in.RedisConfig, &out.RedisConfig
+		*out = new(commonv1beta2.RedisConfig)
+		(*in).DeepCopyInto(*out)
+	}
+	in.RedisLeader.DeepCopyInto(&out.RedisLeader)
+	in.RedisFollower.DeepCopyInto(&out.RedisFollower)
+	if in.RedisExporter != nil {
+		in, out := &in.RedisExporter, &out.RedisExporter
+		*out = new(commonv1beta2.RedisExporter)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Storage != nil {
+		in, out := &in.Storage, &out.Storage
+		*out = new(ClusterStorage)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.PodSecurityContext != nil {
+		in, out := &in.PodSecurityContext, &out.PodSecurityContext
+		*out = new(v1.PodSecurityContext)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Resources != nil {
+		in, out := &in.Resources, &out.Resources
+		*out = new(v1.ResourceRequirements)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.TLS != nil {
+		in, out := &in.TLS, &out.TLS
+		*out = new(commonv1beta2.TLSConfig)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.ACL != nil {
+		in, out := &in.ACL, &out.ACL
+		*out = new(commonv1beta2.ACLConfig)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.InitContainer != nil {
+		in, out := &in.InitContainer, &out.InitContainer
+		*out = new(commonv1beta2.InitContainer)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Sidecars != nil {
+		in, out := &in.Sidecars, &out.Sidecars
+		*out = new([]commonv1beta2.Sidecar)
+		if **in != nil {
+			in, out := *in, *out
+			*out = make([]commonv1beta2.Sidecar, len(*in))
+			for i := range *in {
+				(*in)[i].DeepCopyInto(&(*out)[i])
+			}
+		}
+	}
+	if in.ServiceAccountName != nil {
+		in, out := &in.ServiceAccountName, &out.ServiceAccountName
+		*out = new(string)
+		**out = **in
+	}
+	if in.PersistenceEnabled != nil {
+		in, out := &in.PersistenceEnabled, &out.PersistenceEnabled
+		*out = new(bool)
+		**out = **in
+	}
+	if in.EnvVars != nil {
+		in, out := &in.EnvVars, &out.EnvVars
+		*out = new([]v1.EnvVar)
+		if **in != nil {
+			in, out := *in, *out
+			*out = make([]v1.EnvVar, len(*in))
+			for i := range *in {
+				(*in)[i].DeepCopyInto(&(*out)[i])
+			}
+		}
+	}
+	if in.HostPort != nil {
+		in, out := &in.HostPort, &out.HostPort
+		*out = new(int)
+		**out = **in
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisClusterSpec.
+func (in *RedisClusterSpec) DeepCopy() *RedisClusterSpec {
+	if in == nil {
+		return nil
+	}
+	out := new(RedisClusterSpec)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *RedisClusterStatus) DeepCopyInto(out *RedisClusterStatus) {
+	*out = *in
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisClusterStatus.
+func (in *RedisClusterStatus) DeepCopy() *RedisClusterStatus {
+	if in == nil {
+		return nil
+	}
+	out := new(RedisClusterStatus)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *RedisFollower) DeepCopyInto(out *RedisFollower) {
+	*out = *in
+	in.RedisFollower.DeepCopyInto(&out.RedisFollower)
+	if in.SecurityContext != nil {
+		in, out := &in.SecurityContext, &out.SecurityContext
+		*out = new(v1.SecurityContext)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.TerminationGracePeriodSeconds != nil {
+		in, out := &in.TerminationGracePeriodSeconds, &out.TerminationGracePeriodSeconds
+		*out = new(int64)
+		**out = **in
+	}
+	if in.Resources != nil {
+		in, out := &in.Resources, &out.Resources
+		*out = new(v1.ResourceRequirements)
+		(*in).DeepCopyInto(*out)
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisFollower.
+func (in *RedisFollower) DeepCopy() *RedisFollower {
+	if in == nil {
+		return nil
+	}
+	out := new(RedisFollower)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *RedisLeader) DeepCopyInto(out *RedisLeader) {
+	*out = *in
+	in.RedisLeader.DeepCopyInto(&out.RedisLeader)
+	if in.SecurityContext != nil {
+		in, out := &in.SecurityContext, &out.SecurityContext
+		*out = new(v1.SecurityContext)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.TerminationGracePeriodSeconds != nil {
+		in, out := &in.TerminationGracePeriodSeconds, &out.TerminationGracePeriodSeconds
+		*out = new(int64)
+		**out = **in
+	}
+	if in.Resources != nil {
+		in, out := &in.Resources, &out.Resources
+		*out = new(v1.ResourceRequirements)
+		(*in).DeepCopyInto(*out)
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisLeader.
+func (in *RedisLeader) DeepCopy() *RedisLeader {
+	if in == nil {
+		return nil
+	}
+	out := new(RedisLeader)
+	in.DeepCopyInto(out)
+	return out
+}

api/redisreplication/v1beta2/groupversion_info.go

@@ -0,0 +1,36 @@
+/*
+Copyright 2020 Opstree Solutions.
+
+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.
+*/
+
+// Package v1beta2 contains API Schema definitions for the redis v1beta2 API group
+// +kubebuilder:object:generate=true
+// +groupName=redis.redis.opstreelabs.in
+package v1beta2
+
+import (
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"sigs.k8s.io/controller-runtime/pkg/scheme"
+)
+
+var (
+	// GroupVersion is group version used to register these objects
+	GroupVersion = schema.GroupVersion{Group: "redis.redis.opstreelabs.in", Version: "v1beta2"}
+
+	// SchemeBuilder is used to add go types to the GroupVersionKind scheme
+	SchemeBuilder = &scheme.Builder{GroupVersion: GroupVersion}
+
+	// AddToScheme adds the types in this group-version to the given scheme.
+	AddToScheme = SchemeBuilder.AddToScheme
+)

api/redisreplication/v1beta2/redisreplication_types.go

@@ -0,0 +1,76 @@
+package v1beta2
+
+import (
+	common "github.com/OT-CONTAINER-KIT/redis-operator/api/common/v1beta2"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+type RedisReplicationSpec struct {
+	Size                          *int32                            `json:"clusterSize"`
+	KubernetesConfig              common.KubernetesConfig           `json:"kubernetesConfig"`
+	RedisExporter                 *common.RedisExporter             `json:"redisExporter,omitempty"`
+	RedisConfig                   *common.RedisConfig               `json:"redisConfig,omitempty"`
+	Storage                       *common.Storage                   `json:"storage,omitempty"`
+	NodeSelector                  map[string]string                 `json:"nodeSelector,omitempty"`
+	PodSecurityContext            *corev1.PodSecurityContext        `json:"podSecurityContext,omitempty"`
+	SecurityContext               *corev1.SecurityContext           `json:"securityContext,omitempty"`
+	PriorityClassName             string                            `json:"priorityClassName,omitempty"`
+	Affinity                      *corev1.Affinity                  `json:"affinity,omitempty"`
+	Tolerations                   *[]corev1.Toleration              `json:"tolerations,omitempty"`
+	TLS                           *common.TLSConfig                 `json:"TLS,omitempty"`
+	PodDisruptionBudget           *common.RedisPodDisruptionBudget  `json:"pdb,omitempty"`
+	ACL                           *common.ACLConfig                 `json:"acl,omitempty"`
+	ReadinessProbe                *corev1.Probe                     `json:"readinessProbe,omitempty" protobuf:"bytes,11,opt,name=readinessProbe"`
+	LivenessProbe                 *corev1.Probe                     `json:"livenessProbe,omitempty" protobuf:"bytes,12,opt,name=livenessProbe"`
+	InitContainer                 *common.InitContainer             `json:"initContainer,omitempty"`
+	Sidecars                      *[]common.Sidecar                 `json:"sidecars,omitempty"`
+	ServiceAccountName            *string                           `json:"serviceAccountName,omitempty"`
+	TerminationGracePeriodSeconds *int64                            `json:"terminationGracePeriodSeconds,omitempty" protobuf:"varint,4,opt,name=terminationGracePeriodSeconds"`
+	EnvVars                       *[]corev1.EnvVar                  `json:"env,omitempty"`
+	TopologySpreadConstrains      []corev1.TopologySpreadConstraint `json:"topologySpreadConstraints,omitempty"`
+	HostPort                      *int                              `json:"hostPort,omitempty"`
+}
+
+func (cr *RedisReplicationSpec) GetReplicationCounts(t string) int32 {
+	replica := cr.Size
+	return *replica
+}
+
+// RedisStatus defines the observed state of Redis
+type RedisReplicationStatus struct {
+	MasterNode string `json:"masterNode,omitempty"`
+}
+
+// +kubebuilder:object:root=true
+// +kubebuilder:subresource:status
+// +kubebuilder:storageversion
+// +kubebuilder:printcolumn:name="Master",type="string",JSONPath=".status.masterNode"
+// +kubebuilder:printcolumn:name="Age",type="date",JSONPath=".metadata.creationTimestamp"
+
+// Redis is the Schema for the redis API
+type RedisReplication struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	Spec   RedisReplicationSpec   `json:"spec"`
+	Status RedisReplicationStatus `json:"status,omitempty"`
+}
+
+func (rr *RedisReplication) GetStatefulSetName() string {
+	return rr.Name
+}
+
+// +kubebuilder:object:root=true
+
+// RedisList contains a list of Redis
+type RedisReplicationList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []RedisReplication `json:"items"`
+}
+
+//nolint:gochecknoinits
+func init() {
+	SchemeBuilder.Register(&RedisReplication{}, &RedisReplicationList{})
+}

api/redisreplication/v1beta2/redisreplication_webhook.go

@@ -18,12 +18,8 @@ package v1beta2
 
 import (
 	ctrl "sigs.k8s.io/controller-runtime"
-	logf "sigs.k8s.io/controller-runtime/pkg/log"
 )
 
-// log is for logging in this package.
-var redisreplicationlog = logf.Log.WithName("redisreplication-resource")
-
 func (r *RedisReplication) SetupWebhookWithManager(mgr ctrl.Manager) error {
 	return ctrl.NewWebhookManagedBy(mgr).
 		For(r).

api/redisreplication/v1beta2/zz_generated.deepcopy.go

@@ -0,0 +1,244 @@
+//go:build !ignore_autogenerated
+
+/*
+Copyright 2020 Opstree Solutions.
+
+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 controller-gen. DO NOT EDIT.
+
+package v1beta2
+
+import (
+	commonv1beta2 "github.com/OT-CONTAINER-KIT/redis-operator/api/common/v1beta2"
+	"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 *RedisReplication) DeepCopyInto(out *RedisReplication) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	in.Spec.DeepCopyInto(&out.Spec)
+	out.Status = in.Status
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisReplication.
+func (in *RedisReplication) DeepCopy() *RedisReplication {
+	if in == nil {
+		return nil
+	}
+	out := new(RedisReplication)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *RedisReplication) 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 *RedisReplicationList) DeepCopyInto(out *RedisReplicationList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ListMeta.DeepCopyInto(&out.ListMeta)
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]RedisReplication, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisReplicationList.
+func (in *RedisReplicationList) DeepCopy() *RedisReplicationList {
+	if in == nil {
+		return nil
+	}
+	out := new(RedisReplicationList)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *RedisReplicationList) 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 *RedisReplicationSpec) DeepCopyInto(out *RedisReplicationSpec) {
+	*out = *in
+	if in.Size != nil {
+		in, out := &in.Size, &out.Size
+		*out = new(int32)
+		**out = **in
+	}
+	in.KubernetesConfig.DeepCopyInto(&out.KubernetesConfig)
+	if in.RedisExporter != nil {
+		in, out := &in.RedisExporter, &out.RedisExporter
+		*out = new(commonv1beta2.RedisExporter)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.RedisConfig != nil {
+		in, out := &in.RedisConfig, &out.RedisConfig
+		*out = new(commonv1beta2.RedisConfig)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Storage != nil {
+		in, out := &in.Storage, &out.Storage
+		*out = new(commonv1beta2.Storage)
+		(*in).DeepCopyInto(*out)
+	}
+	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
+		}
+	}
+	if in.PodSecurityContext != nil {
+		in, out := &in.PodSecurityContext, &out.PodSecurityContext
+		*out = new(v1.PodSecurityContext)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.SecurityContext != nil {
+		in, out := &in.SecurityContext, &out.SecurityContext
+		*out = new(v1.SecurityContext)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Affinity != nil {
+		in, out := &in.Affinity, &out.Affinity
+		*out = new(v1.Affinity)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Tolerations != nil {
+		in, out := &in.Tolerations, &out.Tolerations
+		*out = new([]v1.Toleration)
+		if **in != nil {
+			in, out := *in, *out
+			*out = make([]v1.Toleration, len(*in))
+			for i := range *in {
+				(*in)[i].DeepCopyInto(&(*out)[i])
+			}
+		}
+	}
+	if in.TLS != nil {
+		in, out := &in.TLS, &out.TLS
+		*out = new(commonv1beta2.TLSConfig)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.PodDisruptionBudget != nil {
+		in, out := &in.PodDisruptionBudget, &out.PodDisruptionBudget
+		*out = new(commonv1beta2.RedisPodDisruptionBudget)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.ACL != nil {
+		in, out := &in.ACL, &out.ACL
+		*out = new(commonv1beta2.ACLConfig)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.ReadinessProbe != nil {
+		in, out := &in.ReadinessProbe, &out.ReadinessProbe
+		*out = new(v1.Probe)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.LivenessProbe != nil {
+		in, out := &in.LivenessProbe, &out.LivenessProbe
+		*out = new(v1.Probe)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.InitContainer != nil {
+		in, out := &in.InitContainer, &out.InitContainer
+		*out = new(commonv1beta2.InitContainer)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Sidecars != nil {
+		in, out := &in.Sidecars, &out.Sidecars
+		*out = new([]commonv1beta2.Sidecar)
+		if **in != nil {
+			in, out := *in, *out
+			*out = make([]commonv1beta2.Sidecar, len(*in))
+			for i := range *in {
+				(*in)[i].DeepCopyInto(&(*out)[i])
+			}
+		}
+	}
+	if in.ServiceAccountName != nil {
+		in, out := &in.ServiceAccountName, &out.ServiceAccountName
+		*out = new(string)
+		**out = **in
+	}
+	if in.TerminationGracePeriodSeconds != nil {
+		in, out := &in.TerminationGracePeriodSeconds, &out.TerminationGracePeriodSeconds
+		*out = new(int64)
+		**out = **in
+	}
+	if in.EnvVars != nil {
+		in, out := &in.EnvVars, &out.EnvVars
+		*out = new([]v1.EnvVar)
+		if **in != nil {
+			in, out := *in, *out
+			*out = make([]v1.EnvVar, len(*in))
+			for i := range *in {
+				(*in)[i].DeepCopyInto(&(*out)[i])
+			}
+		}
+	}
+	if in.TopologySpreadConstrains != nil {
+		in, out := &in.TopologySpreadConstrains, &out.TopologySpreadConstrains
+		*out = make([]v1.TopologySpreadConstraint, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	if in.HostPort != nil {
+		in, out := &in.HostPort, &out.HostPort
+		*out = new(int)
+		**out = **in
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisReplicationSpec.
+func (in *RedisReplicationSpec) DeepCopy() *RedisReplicationSpec {
+	if in == nil {
+		return nil
+	}
+	out := new(RedisReplicationSpec)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *RedisReplicationStatus) DeepCopyInto(out *RedisReplicationStatus) {
+	*out = *in
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisReplicationStatus.
+func (in *RedisReplicationStatus) DeepCopy() *RedisReplicationStatus {
+	if in == nil {
+		return nil
+	}
+	out := new(RedisReplicationStatus)
+	in.DeepCopyInto(out)
+	return out
+}

api/redissentinel/v1beta2/groupversion_info.go

@@ -0,0 +1,36 @@
+/*
+Copyright 2020 Opstree Solutions.
+
+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.
+*/
+
+// Package v1beta2 contains API Schema definitions for the redis v1beta2 API group
+// +kubebuilder:object:generate=true
+// +groupName=redis.redis.opstreelabs.in
+package v1beta2
+
+import (
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"sigs.k8s.io/controller-runtime/pkg/scheme"
+)
+
+var (
+	// GroupVersion is group version used to register these objects
+	GroupVersion = schema.GroupVersion{Group: "redis.redis.opstreelabs.in", Version: "v1beta2"}
+
+	// SchemeBuilder is used to add go types to the GroupVersionKind scheme
+	SchemeBuilder = &scheme.Builder{GroupVersion: GroupVersion}
+
+	// AddToScheme adds the types in this group-version to the given scheme.
+	AddToScheme = SchemeBuilder.AddToScheme
+)

api/redissentinel/v1beta2/redissentinel_types.go

@@ -0,0 +1,76 @@
+package v1beta2
+
+import (
+	common "github.com/OT-CONTAINER-KIT/redis-operator/api/common/v1beta2"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+type RedisSentinelSpec struct {
+	// +kubebuilder:validation:Minimum=1
+	// +kubebuilder:default=3
+	Size                          *int32                            `json:"clusterSize"`
+	KubernetesConfig              common.KubernetesConfig           `json:"kubernetesConfig"`
+	RedisExporter                 *common.RedisExporter             `json:"redisExporter,omitempty"`
+	RedisSentinelConfig           *RedisSentinelConfig              `json:"redisSentinelConfig,omitempty"`
+	NodeSelector                  map[string]string                 `json:"nodeSelector,omitempty"`
+	PodSecurityContext            *corev1.PodSecurityContext        `json:"podSecurityContext,omitempty"`
+	SecurityContext               *corev1.SecurityContext           `json:"securityContext,omitempty"`
+	PriorityClassName             string                            `json:"priorityClassName,omitempty"`
+	Affinity                      *corev1.Affinity                  `json:"affinity,omitempty"`
+	Tolerations                   *[]corev1.Toleration              `json:"tolerations,omitempty"`
+	TLS                           *common.TLSConfig                 `json:"TLS,omitempty"`
+	PodDisruptionBudget           *common.RedisPodDisruptionBudget  `json:"pdb,omitempty"`
+	ReadinessProbe                *corev1.Probe                     `json:"readinessProbe,omitempty" protobuf:"bytes,11,opt,name=readinessProbe"`
+	LivenessProbe                 *corev1.Probe                     `json:"livenessProbe,omitempty" protobuf:"bytes,12,opt,name=livenessProbe"`
+	InitContainer                 *common.InitContainer             `json:"initContainer,omitempty"`
+	Sidecars                      *[]common.Sidecar                 `json:"sidecars,omitempty"`
+	ServiceAccountName            *string                           `json:"serviceAccountName,omitempty"`
+	TerminationGracePeriodSeconds *int64                            `json:"terminationGracePeriodSeconds,omitempty" protobuf:"varint,4,opt,name=terminationGracePeriodSeconds"`
+	EnvVars                       *[]corev1.EnvVar                  `json:"env,omitempty"`
+	VolumeMount                   *common.AdditionalVolume          `json:"volumeMount,omitempty"`
+	TopologySpreadConstrains      []corev1.TopologySpreadConstraint `json:"topologySpreadConstraints,omitempty"`
+	HostPort                      *int                              `json:"hostPort,omitempty"`
+}
+
+func (cr *RedisSentinelSpec) GetSentinelCounts(t string) int32 {
+	replica := cr.Size
+	return *replica
+}
+
+type RedisSentinelConfig struct {
+	common.RedisSentinelConfig `json:",inline"`
+}
+
+type RedisSentinelStatus struct{}
+
+// +kubebuilder:object:root=true
+// +kubebuilder:subresource:status
+//+kubebuilder:storageversion
+
+// Redis is the Schema for the redis API
+type RedisSentinel struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	Spec   RedisSentinelSpec   `json:"spec"`
+	Status RedisSentinelStatus `json:"status,omitempty"`
+}
+
+func (rs *RedisSentinel) GetStatefulSetName() string {
+	return rs.Name + "-sentinel"
+}
+
+// +kubebuilder:object:root=true
+
+// RedisList contains a list of Redis
+type RedisSentinelList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []RedisSentinel `json:"items"`
+}
+
+//nolint:gochecknoinits
+func init() {
+	SchemeBuilder.Register(&RedisSentinel{}, &RedisSentinelList{})
+}

api/redissentinel/v1beta2/redissentinel_webhook.go

@@ -0,0 +1,102 @@
+/*
+Copyright 2020 Opstree Solutions.
+
+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.
+*/
+
+package v1beta2
+
+import (
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/validation/field"
+	ctrl "sigs.k8s.io/controller-runtime"
+	logf "sigs.k8s.io/controller-runtime/pkg/log"
+	"sigs.k8s.io/controller-runtime/pkg/webhook"
+	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
+)
+
+const (
+	webhookPath = "/validate-redis-redis-opstreelabs-in-v1beta2-redissentinel"
+)
+
+// log is for logging in this package.
+var redissentinellog = logf.Log.WithName("redissentinel-v1beta2-validation")
+
+// +kubebuilder:webhook:path=/validate-redis-redis-opstreelabs-in-v1beta2-redissentinel,mutating=false,failurePolicy=fail,sideEffects=None,groups=redis.redis.opstreelabs.in,resources=redissentinels,verbs=create;update,versions=v1beta2,name=validate-redissentinel.redis.opstreelabs.in,admissionReviewVersions=v1
+
+// SetupWebhookWithManager will setup the manager
+func (r *RedisSentinel) SetupWebhookWithManager(mgr ctrl.Manager) error {
+	return ctrl.NewWebhookManagedBy(mgr).
+		For(r).
+		Complete()
+}
+
+var _ webhook.Validator = &RedisSentinel{}
+
+// ValidateCreate implements webhook.Validator so a webhook will be registered for the type
+func (r *RedisSentinel) ValidateCreate() (admission.Warnings, error) {
+	redissentinellog.Info("validate create", "name", r.Name)
+
+	return r.validate(nil)
+}
+
+// ValidateUpdate implements webhook.Validator so a webhook will be registered for the type
+func (r *RedisSentinel) ValidateUpdate(old runtime.Object) (admission.Warnings, error) {
+	redissentinellog.Info("validate update", "name", r.Name)
+
+	return r.validate(old.(*RedisSentinel))
+}
+
+// ValidateDelete implements webhook.Validator so a webhook will be registered for the type
+func (r *RedisSentinel) ValidateDelete() (admission.Warnings, error) {
+	redissentinellog.Info("validate delete", "name", r.Name)
+
+	return nil, nil
+}
+
+// validate validates the Redis Sentinel CR
+func (r *RedisSentinel) validate(_ *RedisSentinel) (admission.Warnings, error) {
+	var errors field.ErrorList
+	var warnings admission.Warnings
+
+	if r.Spec.Size == nil {
+		return warnings, nil
+	}
+
+	// Check if the Size is an odd number
+	if *r.Spec.Size%2 == 0 {
+		errors = append(errors, field.Invalid(
+			field.NewPath("spec").Child("clusterSize"),
+			*r.Spec.Size,
+			"Redis Sentinel cluster size must be an odd number for proper leader election",
+		))
+	}
+
+	if len(errors) == 0 {
+		return nil, nil
+	}
+
+	return nil, apierrors.NewInvalid(
+		schema.GroupKind{Group: "redis.redis.opstreelabs.in", Kind: "RedisSentinel"},
+		r.Name,
+		errors,
+	)
+}
+
+func (r *RedisSentinel) WebhookPath() string {
+	return webhookPath
+}
+
+// TODO(user): EDIT THIS FILE!  THIS IS SCAFFOLDING FOR YOU TO OWN!

api/redissentinel/v1beta2/redissentinel_webhook_test.go

@@ -0,0 +1,69 @@
+package v1beta2_test
+
+import (
+	"encoding/json"
+	"fmt"
+	"testing"
+
+	v1beta2 "github.com/OT-CONTAINER-KIT/redis-operator/api/redissentinel/v1beta2"
+	"github.com/OT-CONTAINER-KIT/redis-operator/internal/testutil/webhook"
+	"github.com/stretchr/testify/require"
+	admissionv1beta1 "k8s.io/api/admission/v1beta1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/utils/ptr"
+)
+
+func TestRedisSentinelWebhook(t *testing.T) {
+	cases := []webhook.ValidationWebhookTestCase{
+		{
+			Name:      "success-create-v1beta2-redissentinel-validate-clusterSize",
+			Operation: admissionv1beta1.Create,
+			Object: func(t *testing.T, uid string) []byte {
+				t.Helper()
+				sentinel := mkRedisSentinel(uid)
+				sentinel.Spec.Size = ptr.To(int32(3))
+				return marshal(t, sentinel)
+			},
+			Check: webhook.ValidationWebhookSucceeded,
+		},
+
+		{
+			Name:      "failed-create-v1beta2-redissentinel-validate-clusterSize",
+			Operation: admissionv1beta1.Create,
+			Object: func(t *testing.T, uid string) []byte {
+				t.Helper()
+				sentinel := mkRedisSentinel(uid)
+				sentinel.Spec.Size = ptr.To(int32(4))
+				return marshal(t, sentinel)
+			},
+			Check: webhook.ValidationWebhookFailed("Redis Sentinel cluster size must be an odd number for proper leader election"),
+		},
+	}
+
+	gvk := metav1.GroupVersionKind{
+		Group:   "redis.redis.opstreelabs.in",
+		Version: "v1beta2",
+		Kind:    "RedisSentinel",
+	}
+
+	sentinel := &v1beta2.RedisSentinel{}
+	webhook.RunValidationWebhookTests(t, gvk, sentinel, cases...)
+}
+
+func mkRedisSentinel(uid string) *v1beta2.RedisSentinel {
+	return &v1beta2.RedisSentinel{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: fmt.Sprintf("test-%s", uid),
+			UID:  types.UID(fmt.Sprintf("test-%s", uid)),
+		},
+		Spec: v1beta2.RedisSentinelSpec{},
+	}
+}
+
+func marshal(t *testing.T, obj interface{}) []byte {
+	t.Helper()
+	bytes, err := json.Marshal(obj)
+	require.NoError(t, err)
+	return bytes
+}

api/redissentinel/v1beta2/zz_generated.deepcopy.go

@@ -0,0 +1,255 @@
+//go:build !ignore_autogenerated
+
+/*
+Copyright 2020 Opstree Solutions.
+
+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 controller-gen. DO NOT EDIT.
+
+package v1beta2
+
+import (
+	commonv1beta2 "github.com/OT-CONTAINER-KIT/redis-operator/api/common/v1beta2"
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+)
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *RedisSentinel) DeepCopyInto(out *RedisSentinel) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	in.Spec.DeepCopyInto(&out.Spec)
+	out.Status = in.Status
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisSentinel.
+func (in *RedisSentinel) DeepCopy() *RedisSentinel {
+	if in == nil {
+		return nil
+	}
+	out := new(RedisSentinel)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *RedisSentinel) 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 *RedisSentinelConfig) DeepCopyInto(out *RedisSentinelConfig) {
+	*out = *in
+	in.RedisSentinelConfig.DeepCopyInto(&out.RedisSentinelConfig)
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisSentinelConfig.
+func (in *RedisSentinelConfig) DeepCopy() *RedisSentinelConfig {
+	if in == nil {
+		return nil
+	}
+	out := new(RedisSentinelConfig)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *RedisSentinelList) DeepCopyInto(out *RedisSentinelList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ListMeta.DeepCopyInto(&out.ListMeta)
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]RedisSentinel, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisSentinelList.
+func (in *RedisSentinelList) DeepCopy() *RedisSentinelList {
+	if in == nil {
+		return nil
+	}
+	out := new(RedisSentinelList)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *RedisSentinelList) 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 *RedisSentinelSpec) DeepCopyInto(out *RedisSentinelSpec) {
+	*out = *in
+	if in.Size != nil {
+		in, out := &in.Size, &out.Size
+		*out = new(int32)
+		**out = **in
+	}
+	in.KubernetesConfig.DeepCopyInto(&out.KubernetesConfig)
+	if in.RedisExporter != nil {
+		in, out := &in.RedisExporter, &out.RedisExporter
+		*out = new(commonv1beta2.RedisExporter)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.RedisSentinelConfig != nil {
+		in, out := &in.RedisSentinelConfig, &out.RedisSentinelConfig
+		*out = new(RedisSentinelConfig)
+		(*in).DeepCopyInto(*out)
+	}
+	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
+		}
+	}
+	if in.PodSecurityContext != nil {
+		in, out := &in.PodSecurityContext, &out.PodSecurityContext
+		*out = new(v1.PodSecurityContext)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.SecurityContext != nil {
+		in, out := &in.SecurityContext, &out.SecurityContext
+		*out = new(v1.SecurityContext)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Affinity != nil {
+		in, out := &in.Affinity, &out.Affinity
+		*out = new(v1.Affinity)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Tolerations != nil {
+		in, out := &in.Tolerations, &out.Tolerations
+		*out = new([]v1.Toleration)
+		if **in != nil {
+			in, out := *in, *out
+			*out = make([]v1.Toleration, len(*in))
+			for i := range *in {
+				(*in)[i].DeepCopyInto(&(*out)[i])
+			}
+		}
+	}
+	if in.TLS != nil {
+		in, out := &in.TLS, &out.TLS
+		*out = new(commonv1beta2.TLSConfig)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.PodDisruptionBudget != nil {
+		in, out := &in.PodDisruptionBudget, &out.PodDisruptionBudget
+		*out = new(commonv1beta2.RedisPodDisruptionBudget)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.ReadinessProbe != nil {
+		in, out := &in.ReadinessProbe, &out.ReadinessProbe
+		*out = new(v1.Probe)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.LivenessProbe != nil {
+		in, out := &in.LivenessProbe, &out.LivenessProbe
+		*out = new(v1.Probe)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.InitContainer != nil {
+		in, out := &in.InitContainer, &out.InitContainer
+		*out = new(commonv1beta2.InitContainer)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.Sidecars != nil {
+		in, out := &in.Sidecars, &out.Sidecars
+		*out = new([]commonv1beta2.Sidecar)
+		if **in != nil {
+			in, out := *in, *out
+			*out = make([]commonv1beta2.Sidecar, len(*in))
+			for i := range *in {
+				(*in)[i].DeepCopyInto(&(*out)[i])
+			}
+		}
+	}
+	if in.ServiceAccountName != nil {
+		in, out := &in.ServiceAccountName, &out.ServiceAccountName
+		*out = new(string)
+		**out = **in
+	}
+	if in.TerminationGracePeriodSeconds != nil {
+		in, out := &in.TerminationGracePeriodSeconds, &out.TerminationGracePeriodSeconds
+		*out = new(int64)
+		**out = **in
+	}
+	if in.EnvVars != nil {
+		in, out := &in.EnvVars, &out.EnvVars
+		*out = new([]v1.EnvVar)
+		if **in != nil {
+			in, out := *in, *out
+			*out = make([]v1.EnvVar, len(*in))
+			for i := range *in {
+				(*in)[i].DeepCopyInto(&(*out)[i])
+			}
+		}
+	}
+	if in.VolumeMount != nil {
+		in, out := &in.VolumeMount, &out.VolumeMount
+		*out = new(commonv1beta2.AdditionalVolume)
+		(*in).DeepCopyInto(*out)
+	}
+	if in.TopologySpreadConstrains != nil {
+		in, out := &in.TopologySpreadConstrains, &out.TopologySpreadConstrains
+		*out = make([]v1.TopologySpreadConstraint, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	if in.HostPort != nil {
+		in, out := &in.HostPort, &out.HostPort
+		*out = new(int)
+		**out = **in
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisSentinelSpec.
+func (in *RedisSentinelSpec) DeepCopy() *RedisSentinelSpec {
+	if in == nil {
+		return nil
+	}
+	out := new(RedisSentinelSpec)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *RedisSentinelStatus) DeepCopyInto(out *RedisSentinelStatus) {
+	*out = *in
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisSentinelStatus.
+func (in *RedisSentinelStatus) DeepCopy() *RedisSentinelStatus {
+	if in == nil {
+		return nil
+	}
+	out := new(RedisSentinelStatus)
+	in.DeepCopyInto(out)
+	return out
+}

api/status/redis-cluster_status.go

@@ -1,18 +0,0 @@
-package status
-
-type RedisClusterState string
-
-const (
-	ReadyClusterReason                string = "RedisCluster is ready"
-	InitializingClusterLeaderReason   string = "RedisCluster is initializing leaders"
-	InitializingClusterFollowerReason string = "RedisCluster is initializing followers"
-	BootstrapClusterReason            string = "RedisCluster is bootstrapping"
-)
-
-// Status Field of the Redis Cluster
-const (
-	RedisClusterReady        RedisClusterState = "Ready"
-	RedisClusterInitializing RedisClusterState = "Initializing"
-	RedisClusterBootstrap    RedisClusterState = "Bootstrap"
-	// RedisClusterFailed       RedisClusterState = "Failed"
-)

api/v1beta1/common_types.go

@@ -1,69 +0,0 @@
-/*
-Copyright 2020 Opstree Solutions.
-
-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.
-*/
-
-package v1beta1
-
-import (
-	common "github.com/OT-CONTAINER-KIT/redis-operator/api"
-)
-
-// KubernetesConfig will be the JSON struct for Basic Redis Config
-type KubernetesConfig struct {
-	common.KubernetesConfig `json:",inline"`
-}
-
-// ServiceConfig define the type of service to be created and its annotations
-type ServiceConfig struct {
-	// +kubebuilder:validation:Enum=LoadBalancer;NodePort;ClusterIP
-	ServiceType        string            `json:"serviceType,omitempty"`
-	ServiceAnnotations map[string]string `json:"annotations,omitempty"`
-}
-
-// RedisConfig defines the external configuration of Redis
-type RedisConfig struct {
-	common.RedisConfig `json:",inline"`
-}
-
-// ExistingPasswordSecret is the struct to access the existing secret
-type ExistingPasswordSecret struct {
-	Name *string `json:"name,omitempty"`
-	Key  *string `json:"key,omitempty"`
-}
-
-// Storage is the inteface to add pvc and pv support in redis
-type Storage struct {
-	common.Storage `json:",inline"`
-}
-
-// RedisExporter interface will have the information for redis exporter related stuff
-type RedisExporter struct {
-	common.RedisExporter `json:",inline"`
-}
-
-// TLS Configuration for redis instances
-type TLSConfig struct {
-	common.TLSConfig `json:",inline"`
-}
-
-// Probe is a interface for ReadinessProbe and LivenessProbe
-type Probe struct {
-	common.Probe `json:",inline"`
-}
-
-// Sidecar for each Redis pods
-type Sidecar struct {
-	common.Sidecar `json:",inline"`
-}

api/v1beta1/redis_conversion.go

@@ -1,167 +0,0 @@
-package v1beta1
-
-import (
-	redisv1beta2 "github.com/OT-CONTAINER-KIT/redis-operator/api/v1beta2"
-	"sigs.k8s.io/controller-runtime/pkg/conversion"
-)
-
-// ConvertTo converts this Redis to the Hub version (vbeta2).
-func (src *Redis) ConvertTo(dstRaw conversion.Hub) error {
-	dst := dstRaw.(*redisv1beta2.Redis)
-
-	// if src == nil {
-	// 	return errors.New("source is nil")
-	// }
-	// ObjectMeta
-	dst.ObjectMeta = src.ObjectMeta
-
-	// KubernetesConfig
-	dst.Spec.KubernetesConfig.KubernetesConfig = src.Spec.KubernetesConfig.KubernetesConfig
-	// RedisExporter
-	if src.Spec.RedisExporter != nil {
-		dst.Spec.RedisExporter = &redisv1beta2.RedisExporter{}
-		dst.Spec.RedisExporter.RedisExporter = src.Spec.RedisExporter.RedisExporter
-	}
-	// RedisConfig
-	if src.Spec.RedisConfig != nil {
-		dst.Spec.RedisConfig = &redisv1beta2.RedisConfig{}
-		dst.Spec.RedisConfig.RedisConfig = src.Spec.RedisConfig.RedisConfig
-	}
-	// Storage
-	if src.Spec.Storage != nil {
-		dst.Spec.Storage = &redisv1beta2.Storage{}
-		dst.Spec.Storage.VolumeClaimTemplate = src.Spec.Storage.VolumeClaimTemplate
-		dst.Spec.Storage.VolumeMount = src.Spec.Storage.VolumeMount
-	}
-	// NodeSelector
-	if src.Spec.NodeSelector != nil {
-		dst.Spec.NodeSelector = src.Spec.NodeSelector
-	}
-	// SecurityContext >> PodSecurityContext
-	if src.Spec.SecurityContext != nil {
-		dst.Spec.PodSecurityContext = src.Spec.SecurityContext
-	}
-	// PriorityClassName
-	if src.Spec.PriorityClassName != "" {
-		dst.Spec.PriorityClassName = src.Spec.PriorityClassName
-	}
-	// Affinity
-	if src.Spec.Affinity != nil {
-		dst.Spec.Affinity = src.Spec.Affinity
-	}
-	// Tolerations
-	if src.Spec.Tolerations != nil {
-		dst.Spec.Tolerations = src.Spec.Tolerations
-	}
-	// TLS
-	if src.Spec.TLS != nil {
-		dst.Spec.TLS = &redisv1beta2.TLSConfig{}
-		dst.Spec.TLS.TLSConfig = src.Spec.TLS.TLSConfig
-	}
-	// ReadinessProbe
-	if src.Spec.ReadinessProbe != nil {
-		dst.Spec.ReadinessProbe = &redisv1beta2.Probe{}
-		dst.Spec.ReadinessProbe.Probe = src.Spec.ReadinessProbe.Probe
-	}
-	// LivenessProbe
-	if src.Spec.LivenessProbe != nil {
-		dst.Spec.LivenessProbe = &redisv1beta2.Probe{}
-		dst.Spec.LivenessProbe.Probe = src.Spec.LivenessProbe.Probe
-	}
-	// Sidecars
-	if src.Spec.Sidecars != nil {
-		var sidecars []redisv1beta2.Sidecar
-		for _, sidecar := range *src.Spec.Sidecars {
-			sidecars = append(sidecars, redisv1beta2.Sidecar{
-				Sidecar: sidecar.Sidecar,
-			})
-		}
-		dst.Spec.Sidecars = &sidecars
-	}
-	// ServiceAccountName
-	if src.Spec.ServiceAccountName != nil {
-		dst.Spec.ServiceAccountName = src.Spec.ServiceAccountName
-	}
-
-	return nil
-}
-
-// ConvertFrom converts from the Hub version (vbeta2) to this version.
-func (dst *Redis) ConvertFrom(srcRaw conversion.Hub) error {
-	src := srcRaw.(*redisv1beta2.Redis)
-
-	// if src == nil {
-	// 	return errors.New("source is nil")
-	// }
-	// ObjectMeta
-	dst.ObjectMeta = src.ObjectMeta
-
-	// KubernetesConfig
-	dst.Spec.KubernetesConfig.KubernetesConfig = src.Spec.KubernetesConfig.KubernetesConfig
-	// RedisExporter
-	if src.Spec.RedisExporter != nil {
-		dst.Spec.RedisExporter = &RedisExporter{}
-		dst.Spec.RedisExporter.RedisExporter = src.Spec.RedisExporter.RedisExporter
-	}
-	// RedisConfig
-	if src.Spec.RedisConfig != nil {
-		dst.Spec.RedisConfig = &RedisConfig{}
-		dst.Spec.RedisConfig.RedisConfig = src.Spec.RedisConfig.RedisConfig
-	}
-	// Storage
-	if src.Spec.Storage != nil {
-		dst.Spec.Storage = &Storage{}
-		dst.Spec.Storage.VolumeClaimTemplate = src.Spec.Storage.VolumeClaimTemplate
-		dst.Spec.Storage.VolumeMount = src.Spec.Storage.VolumeMount
-	}
-	// NodeSelector
-	if src.Spec.NodeSelector != nil {
-		dst.Spec.NodeSelector = src.Spec.NodeSelector
-	}
-	//  PodSecurityContext >> SecurityContext
-	if src.Spec.PodSecurityContext != nil {
-		dst.Spec.SecurityContext = src.Spec.PodSecurityContext
-	}
-	// PriorityClassName
-	if src.Spec.PriorityClassName != "" {
-		dst.Spec.PriorityClassName = src.Spec.PriorityClassName
-	}
-	// Affinity
-	if src.Spec.Affinity != nil {
-		dst.Spec.Affinity = src.Spec.Affinity
-	}
-	// Tolerations
-	if src.Spec.Tolerations != nil {
-		dst.Spec.Tolerations = src.Spec.Tolerations
-	}
-	// TLS
-	if src.Spec.TLS != nil {
-		dst.Spec.TLS = &TLSConfig{}
-		dst.Spec.TLS.TLSConfig = src.Spec.TLS.TLSConfig
-	}
-	// ReadinessProbe
-	if src.Spec.ReadinessProbe != nil {
-		dst.Spec.ReadinessProbe = &Probe{}
-		dst.Spec.ReadinessProbe.Probe = src.Spec.ReadinessProbe.Probe
-	}
-	// LivenessProbe
-	if src.Spec.LivenessProbe != nil {
-		dst.Spec.LivenessProbe = &Probe{}
-		dst.Spec.LivenessProbe.Probe = src.Spec.LivenessProbe.Probe
-	}
-	// Sidecars
-	if src.Spec.Sidecars != nil {
-		var sidecars []Sidecar
-		for _, sidecar := range *src.Spec.Sidecars {
-			sidecars = append(sidecars, Sidecar{
-				Sidecar: sidecar.Sidecar,
-			})
-		}
-		dst.Spec.Sidecars = &sidecars
-	}
-	// ServiceAccountName
-	if src.Spec.ServiceAccountName != nil {
-		dst.Spec.ServiceAccountName = src.Spec.ServiceAccountName
-	}
-	return nil
-}

api/v1beta1/redis_types.go

@@ -1,74 +0,0 @@
-/*
-Copyright 2020 Opstree Solutions.
-
-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.
-*/
-
-package v1beta1
-
-import (
-	corev1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-// EDIT THIS FILE!  THIS IS SCAFFOLDING FOR YOU TO OWN!
-// NOTE: json tags are required.  Any new fields you add must have json tags for the fields to be serialized.
-
-// RedisSpec defines the desired state of Redis
-type RedisSpec struct {
-	KubernetesConfig  KubernetesConfig           `json:"kubernetesConfig"`
-	RedisExporter     *RedisExporter             `json:"redisExporter,omitempty"`
-	RedisConfig       *RedisConfig               `json:"redisConfig,omitempty"`
-	Storage           *Storage                   `json:"storage,omitempty"`
-	NodeSelector      map[string]string          `json:"nodeSelector,omitempty"`
-	SecurityContext   *corev1.PodSecurityContext `json:"securityContext,omitempty"`
-	PriorityClassName string                     `json:"priorityClassName,omitempty"`
-	Affinity          *corev1.Affinity           `json:"affinity,omitempty"`
-	Tolerations       *[]corev1.Toleration       `json:"tolerations,omitempty"`
-	TLS               *TLSConfig                 `json:"TLS,omitempty"`
-	// +kubebuilder:default:={initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}
-	ReadinessProbe *Probe `json:"readinessProbe,omitempty" protobuf:"bytes,11,opt,name=readinessProbe"`
-	// +kubebuilder:default:={initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}
-	LivenessProbe      *Probe     `json:"livenessProbe,omitempty" protobuf:"bytes,11,opt,name=livenessProbe"`
-	Sidecars           *[]Sidecar `json:"sidecars,omitempty"`
-	ServiceAccountName *string    `json:"serviceAccountName,omitempty"`
-}
-
-// RedisStatus defines the observed state of Redis
-type RedisStatus struct {
-}
-
-// +kubebuilder:object:root=true
-// +kubebuilder:subresource:status
-
-// Redis is the Schema for the redis API
-type Redis struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	Spec   RedisSpec   `json:"spec"`
-	Status RedisStatus `json:"status,omitempty"`
-}
-
-// +kubebuilder:object:root=true
-
-// RedisList contains a list of Redis
-type RedisList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata,omitempty"`
-	Items           []Redis `json:"items"`
-}
-
-func init() {
-	SchemeBuilder.Register(&Redis{}, &RedisList{})
-}

api/v1beta1/rediscluster_conversion.go

@@ -1,245 +0,0 @@
-package v1beta1
-
-import (
-	redisv1beta2 "github.com/OT-CONTAINER-KIT/redis-operator/api/v1beta2"
-	"sigs.k8s.io/controller-runtime/pkg/conversion"
-)
-
-// ConvertTo converts this RedisCluster to the Hub version (v1beta2) from the current version (v1beta1)
-
-func (src *RedisCluster) ConvertTo(dstRaw conversion.Hub) error {
-	dst := dstRaw.(*redisv1beta2.RedisCluster)
-	// ObjectMeta
-	dst.ObjectMeta = src.ObjectMeta
-
-	// Size
-	if src.Spec.Size != nil {
-		dst.Spec.Size = src.Spec.Size
-	}
-	// KubernetesConfig
-	dst.Spec.KubernetesConfig.KubernetesConfig = src.Spec.KubernetesConfig.KubernetesConfig
-	// ClusterVersion
-	if src.Spec.ClusterVersion != nil {
-		dst.Spec.ClusterVersion = src.Spec.ClusterVersion
-	}
-	// RedisLeader
-	dst.Spec.RedisLeader = redisv1beta2.RedisLeader{}
-	if src.Spec.RedisLeader.Replicas != nil {
-		dst.Spec.RedisLeader.Replicas = src.Spec.RedisLeader.Replicas
-	}
-	if src.Spec.RedisLeader.RedisConfig != nil {
-		dst.Spec.RedisLeader.RedisConfig = src.Spec.RedisLeader.RedisConfig
-	}
-	if src.Spec.RedisLeader.Affinity != nil {
-		dst.Spec.RedisLeader.Affinity = src.Spec.RedisLeader.Affinity
-	}
-	if src.Spec.RedisLeader.PodDisruptionBudget != nil {
-		dst.Spec.RedisLeader.PodDisruptionBudget = src.Spec.RedisLeader.PodDisruptionBudget
-	}
-	if src.Spec.RedisLeader.ReadinessProbe != nil {
-		dst.Spec.RedisLeader.ReadinessProbe = src.Spec.RedisLeader.ReadinessProbe
-	}
-	if src.Spec.RedisLeader.LivenessProbe != nil {
-		dst.Spec.RedisLeader.LivenessProbe = src.Spec.RedisLeader.LivenessProbe
-	}
-	if src.Spec.RedisLeader.Tolerations != nil {
-		dst.Spec.RedisLeader.Tolerations = src.Spec.RedisLeader.Tolerations
-	}
-	if src.Spec.RedisLeader.NodeSelector != nil {
-		dst.Spec.RedisLeader.NodeSelector = src.Spec.RedisLeader.NodeSelector
-	}
-
-	// RedisFollower
-	dst.Spec.RedisFollower = redisv1beta2.RedisFollower{}
-	if src.Spec.RedisFollower.Replicas != nil {
-		dst.Spec.RedisFollower.Replicas = src.Spec.RedisFollower.Replicas
-	}
-	if src.Spec.RedisFollower.RedisConfig != nil {
-		dst.Spec.RedisFollower.RedisConfig = src.Spec.RedisFollower.RedisConfig
-	}
-	if src.Spec.RedisFollower.Affinity != nil {
-		dst.Spec.RedisFollower.Affinity = src.Spec.RedisFollower.Affinity
-	}
-	if src.Spec.RedisFollower.PodDisruptionBudget != nil {
-		dst.Spec.RedisFollower.PodDisruptionBudget = src.Spec.RedisFollower.PodDisruptionBudget
-	}
-	if src.Spec.RedisFollower.ReadinessProbe != nil {
-		dst.Spec.RedisFollower.ReadinessProbe = src.Spec.RedisFollower.ReadinessProbe
-	}
-	if src.Spec.RedisFollower.LivenessProbe != nil {
-		dst.Spec.RedisFollower.LivenessProbe = src.Spec.RedisFollower.LivenessProbe
-	}
-	if src.Spec.RedisFollower.Tolerations != nil {
-		dst.Spec.RedisFollower.Tolerations = src.Spec.RedisFollower.Tolerations
-	}
-	if src.Spec.RedisFollower.NodeSelector != nil {
-		dst.Spec.RedisFollower.NodeSelector = src.Spec.RedisFollower.NodeSelector
-	}
-	// RedisExporter
-	if src.Spec.RedisExporter != nil {
-		dst.Spec.RedisExporter = &redisv1beta2.RedisExporter{}
-		dst.Spec.RedisExporter.RedisExporter = src.Spec.RedisExporter.RedisExporter
-	}
-	// Storage-v1bet1 >> ClusterStorage-v1beta2
-	if src.Spec.Storage != nil {
-		// Note : Add the Check the creation of node-conf later
-		dst.Spec.Storage = &redisv1beta2.ClusterStorage{}
-		dst.Spec.Storage.VolumeClaimTemplate = src.Spec.Storage.VolumeClaimTemplate
-		dst.Spec.Storage.VolumeMount = src.Spec.Storage.VolumeMount
-	}
-	// SecurityContext >> PodSecurityContext
-	if src.Spec.SecurityContext != nil {
-		dst.Spec.PodSecurityContext = src.Spec.SecurityContext
-	}
-	// PriorityClassName
-	if src.Spec.PriorityClassName != "" {
-		dst.Spec.PriorityClassName = src.Spec.PriorityClassName
-	}
-	// Resources
-	if src.Spec.Resources != nil {
-		dst.Spec.Resources = src.Spec.Resources
-	}
-	// TLS
-	if src.Spec.TLS != nil {
-		dst.Spec.TLS = &redisv1beta2.TLSConfig{}
-		dst.Spec.TLS.TLSConfig = src.Spec.TLS.TLSConfig
-	}
-	// Sidecars
-	if src.Spec.Sidecars != nil {
-		var sidecars []redisv1beta2.Sidecar
-		for _, sidecar := range *src.Spec.Sidecars {
-			sidecars = append(sidecars, redisv1beta2.Sidecar{
-				Sidecar: sidecar.Sidecar,
-			})
-		}
-		dst.Spec.Sidecars = &sidecars
-	}
-	// ServiceAccountName
-	if src.Spec.ServiceAccountName != nil {
-		dst.Spec.ServiceAccountName = src.Spec.ServiceAccountName
-	}
-	// PersistenceEnabled
-	if src.Spec.PersistenceEnabled != nil {
-		dst.Spec.PersistenceEnabled = src.Spec.PersistenceEnabled
-	}
-	return nil
-}
-
-// ConvertFrom converts from the Hub version (vbeta2) to this version.
-func (dst *RedisCluster) ConvertFrom(srcRaw conversion.Hub) error {
-	src := srcRaw.(*redisv1beta2.RedisCluster)
-
-	// ObjectMeta
-	dst.ObjectMeta = src.ObjectMeta
-
-	// Size
-	if src.Spec.Size != nil {
-		dst.Spec.Size = src.Spec.Size
-	}
-	// KubernetesConfig
-	dst.Spec.KubernetesConfig.KubernetesConfig = src.Spec.KubernetesConfig.KubernetesConfig
-	// ClusterVersion
-	if src.Spec.ClusterVersion != nil {
-		dst.Spec.ClusterVersion = src.Spec.ClusterVersion
-	}
-	// RedisLeader
-	dst.Spec.RedisLeader = RedisLeader{}
-	if src.Spec.RedisLeader.Replicas != nil {
-		dst.Spec.RedisLeader.Replicas = src.Spec.RedisLeader.Replicas
-	}
-	if src.Spec.RedisLeader.RedisConfig != nil {
-		dst.Spec.RedisLeader.RedisConfig = src.Spec.RedisLeader.RedisConfig
-	}
-	if src.Spec.RedisLeader.Affinity != nil {
-		dst.Spec.RedisLeader.Affinity = src.Spec.RedisLeader.Affinity
-	}
-	if src.Spec.RedisLeader.PodDisruptionBudget != nil {
-		dst.Spec.RedisLeader.PodDisruptionBudget = src.Spec.RedisLeader.PodDisruptionBudget
-	}
-	if src.Spec.RedisLeader.ReadinessProbe != nil {
-		dst.Spec.RedisLeader.ReadinessProbe = src.Spec.RedisLeader.ReadinessProbe
-	}
-	if src.Spec.RedisLeader.LivenessProbe != nil {
-		dst.Spec.RedisLeader.LivenessProbe = src.Spec.RedisLeader.LivenessProbe
-	}
-	if src.Spec.RedisLeader.Tolerations != nil {
-		dst.Spec.RedisLeader.Tolerations = src.Spec.RedisLeader.Tolerations
-	}
-	if src.Spec.RedisLeader.NodeSelector != nil {
-		dst.Spec.RedisLeader.NodeSelector = src.Spec.RedisLeader.NodeSelector
-	}
-
-	// RedisFollower
-	dst.Spec.RedisFollower = RedisFollower{}
-	if src.Spec.RedisFollower.Replicas != nil {
-		dst.Spec.RedisFollower.Replicas = src.Spec.RedisFollower.Replicas
-	}
-	if src.Spec.RedisFollower.RedisConfig != nil {
-		dst.Spec.RedisFollower.RedisConfig = src.Spec.RedisFollower.RedisConfig
-	}
-	if src.Spec.RedisFollower.Affinity != nil {
-		dst.Spec.RedisFollower.Affinity = src.Spec.RedisFollower.Affinity
-	}
-	if src.Spec.RedisFollower.PodDisruptionBudget != nil {
-		dst.Spec.RedisFollower.PodDisruptionBudget = src.Spec.RedisFollower.PodDisruptionBudget
-	}
-	if src.Spec.RedisFollower.ReadinessProbe != nil {
-		dst.Spec.RedisFollower.ReadinessProbe = src.Spec.RedisFollower.ReadinessProbe
-	}
-	if src.Spec.RedisFollower.LivenessProbe != nil {
-		dst.Spec.RedisFollower.LivenessProbe = src.Spec.RedisFollower.LivenessProbe
-	}
-	if src.Spec.RedisFollower.Tolerations != nil {
-		dst.Spec.RedisFollower.Tolerations = src.Spec.RedisFollower.Tolerations
-	}
-	if src.Spec.RedisFollower.NodeSelector != nil {
-		dst.Spec.RedisFollower.NodeSelector = src.Spec.RedisFollower.NodeSelector
-	}
-	// RedisExporter
-	if src.Spec.RedisExporter != nil {
-		dst.Spec.RedisExporter = &RedisExporter{}
-		dst.Spec.RedisExporter.RedisExporter = src.Spec.RedisExporter.RedisExporter
-	}
-	// ClusterStorage(v1beta2) >> Storage(v1beta1)
-	if src.Spec.Storage != nil {
-		dst.Spec.Storage = &Storage{}
-		dst.Spec.Storage.VolumeClaimTemplate = src.Spec.Storage.VolumeClaimTemplate
-		dst.Spec.Storage.VolumeMount = src.Spec.Storage.VolumeMount
-	}
-	//  PodSecurityContext >> SecurityContext
-	if src.Spec.PodSecurityContext != nil {
-		dst.Spec.SecurityContext = src.Spec.PodSecurityContext
-	}
-	// PriorityClassName
-	if src.Spec.PriorityClassName != "" {
-		dst.Spec.PriorityClassName = src.Spec.PriorityClassName
-	}
-	// Resources
-	if src.Spec.Resources != nil {
-		dst.Spec.Resources = src.Spec.Resources
-	}
-	// TLS
-	if src.Spec.TLS != nil {
-		dst.Spec.TLS = &TLSConfig{}
-		dst.Spec.TLS.TLSConfig = src.Spec.TLS.TLSConfig
-	}
-	// Sidecars
-	if src.Spec.Sidecars != nil {
-		var sidecars []Sidecar
-		for _, sidecar := range *src.Spec.Sidecars {
-			sidecars = append(sidecars, Sidecar{
-				Sidecar: sidecar.Sidecar,
-			})
-		}
-		dst.Spec.Sidecars = &sidecars
-	}
-	// ServiceAccountName
-	if src.Spec.ServiceAccountName != nil {
-		dst.Spec.ServiceAccountName = src.Spec.ServiceAccountName
-	}
-	// PersistenceEnabled
-	if src.Spec.PersistenceEnabled != nil {
-		dst.Spec.PersistenceEnabled = src.Spec.PersistenceEnabled
-	}
-	return nil
-}

api/v1beta1/rediscluster_types.go

@@ -1,96 +0,0 @@
-/*
-Copyright 2020 Opstree Solutions.
-
-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.
-*/
-
-package v1beta1
-
-import (
-	common "github.com/OT-CONTAINER-KIT/redis-operator/api"
-	corev1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-// RedisClusterSpec defines the desired state of RedisCluster
-type RedisClusterSpec struct {
-	Size             *int32           `json:"clusterSize"`
-	KubernetesConfig KubernetesConfig `json:"kubernetesConfig"`
-	// +kubebuilder:default:=v7
-	ClusterVersion *string `json:"clusterVersion,omitempty"`
-	// +kubebuilder:default:={livenessProbe:{initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}, readinessProbe:{initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}}
-	RedisLeader RedisLeader `json:"redisLeader,omitempty"`
-	// +kubebuilder:default:={livenessProbe:{initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}, readinessProbe:{initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}}
-	RedisFollower      RedisFollower                `json:"redisFollower,omitempty"`
-	RedisExporter      *RedisExporter               `json:"redisExporter,omitempty"`
-	Storage            *Storage                     `json:"storage,omitempty"`
-	SecurityContext    *corev1.PodSecurityContext   `json:"securityContext,omitempty"`
-	PriorityClassName  string                       `json:"priorityClassName,omitempty"`
-	Resources          *corev1.ResourceRequirements `json:"resources,omitempty"`
-	TLS                *TLSConfig                   `json:"TLS,omitempty"`
-	Sidecars           *[]Sidecar                   `json:"sidecars,omitempty"`
-	ServiceAccountName *string                      `json:"serviceAccountName,omitempty"`
-	PersistenceEnabled *bool                        `json:"persistenceEnabled,omitempty"`
-}
-
-func (cr *RedisClusterSpec) GetReplicaCounts(t string) int32 {
-	replica := cr.Size
-	if t == "leader" && cr.RedisLeader.Replicas != nil {
-		replica = cr.RedisLeader.Replicas
-	} else if t == "follower" && cr.RedisFollower.Replicas != nil {
-		replica = cr.RedisFollower.Replicas
-	}
-	return *replica
-}
-
-// RedisLeader interface will have the redis leader configuration
-type RedisLeader struct {
-	common.RedisLeader `json:",inline"`
-}
-
-// RedisFollower interface will have the redis follower configuration
-type RedisFollower struct {
-	common.RedisFollower `json:",inline"`
-}
-
-// RedisClusterStatus defines the observed state of RedisCluster
-type RedisClusterStatus struct {
-}
-
-// +kubebuilder:object:root=true
-// +kubebuilder:subresource:status
-// +kubebuilder:printcolumn:name="ClusterSize",type=integer,JSONPath=`.spec.clusterSize`,description=Current cluster node count
-// +kubebuilder:printcolumn:name="LeaderReplicas",type=integer,JSONPath=`.spec.redisLeader.CommonAttributes.Replicas`,description=Overridden Leader replica count
-// +kubebuilder:printcolumn:name="FollowerReplicas",type=integer,JSONPath=`.spec.redisFollower.CommonAttributes.Replicas`,description=Overridden Follower replica count
-// +kubebuilder:printcolumn:name="Age",type=date,JSONPath=`.metadata.creationTimestamp`,description=Age of Cluster
-// RedisCluster is the Schema for the redisclusters API
-type RedisCluster struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	Spec   RedisClusterSpec   `json:"spec"`
-	Status RedisClusterStatus `json:"status,omitempty"`
-}
-
-//+kubebuilder:object:root=true
-
-// RedisClusterList contains a list of RedisCluster
-type RedisClusterList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata,omitempty"`
-	Items           []RedisCluster `json:"items"`
-}
-
-func init() {
-	SchemeBuilder.Register(&RedisCluster{}, &RedisClusterList{})
-}

api/v1beta1/redisreplication_conversion.go

@@ -1,164 +0,0 @@
-package v1beta1
-
-import (
-	redisv1beta2 "github.com/OT-CONTAINER-KIT/redis-operator/api/v1beta2"
-	"sigs.k8s.io/controller-runtime/pkg/conversion"
-)
-
-// ConvertTo converts this RedisReplication to the Hub version (vbeta2).
-func (src *RedisReplication) ConvertTo(dstRaw conversion.Hub) error {
-	dst := dstRaw.(*redisv1beta2.RedisReplication)
-
-	// ObjectMeta
-	dst.ObjectMeta = src.ObjectMeta
-
-	// Size
-	dst.Spec.Size = src.Spec.Size
-	// KubernetesConfig
-	dst.Spec.KubernetesConfig.KubernetesConfig = src.Spec.KubernetesConfig.KubernetesConfig
-	// RedisExporter
-	if src.Spec.RedisExporter != nil {
-		dst.Spec.RedisExporter = &redisv1beta2.RedisExporter{}
-		dst.Spec.RedisExporter.RedisExporter = src.Spec.RedisExporter.RedisExporter
-	}
-	// RedisConfig
-	if src.Spec.RedisConfig != nil {
-		dst.Spec.RedisConfig = &redisv1beta2.RedisConfig{}
-		dst.Spec.RedisConfig.RedisConfig = src.Spec.RedisConfig.RedisConfig
-	}
-	// Storage
-	if src.Spec.Storage != nil {
-		dst.Spec.Storage = &redisv1beta2.Storage{}
-		dst.Spec.Storage.VolumeClaimTemplate = src.Spec.Storage.VolumeClaimTemplate
-		dst.Spec.Storage.VolumeMount = src.Spec.Storage.VolumeMount
-	}
-	// NodeSelector
-	if src.Spec.NodeSelector != nil {
-		dst.Spec.NodeSelector = src.Spec.NodeSelector
-	}
-	// SecurityContext >> PodSecurityContext
-	if src.Spec.SecurityContext != nil {
-		dst.Spec.PodSecurityContext = src.Spec.SecurityContext
-	}
-	// PriorityClassName
-	if src.Spec.PriorityClassName != "" {
-		dst.Spec.PriorityClassName = src.Spec.PriorityClassName
-	}
-	// Affinity
-	if src.Spec.Affinity != nil {
-		dst.Spec.Affinity = src.Spec.Affinity
-	}
-	// Tolerations
-	if src.Spec.Tolerations != nil {
-		dst.Spec.Tolerations = src.Spec.Tolerations
-	}
-	// TLS
-	if src.Spec.TLS != nil {
-		dst.Spec.TLS = &redisv1beta2.TLSConfig{}
-		dst.Spec.TLS.TLSConfig = src.Spec.TLS.TLSConfig
-	}
-	// ReadinessProbe
-	if src.Spec.ReadinessProbe != nil {
-		dst.Spec.ReadinessProbe = &redisv1beta2.Probe{}
-		dst.Spec.ReadinessProbe.Probe = src.Spec.ReadinessProbe.Probe
-	}
-	// LivenessProbe
-	if src.Spec.LivenessProbe != nil {
-		dst.Spec.LivenessProbe = &redisv1beta2.Probe{}
-		dst.Spec.LivenessProbe.Probe = src.Spec.LivenessProbe.Probe
-	}
-	// Sidecars
-	if src.Spec.Sidecars != nil {
-		var sidecars []redisv1beta2.Sidecar
-		for _, sidecar := range *src.Spec.Sidecars {
-			sidecars = append(sidecars, redisv1beta2.Sidecar{
-				Sidecar: sidecar.Sidecar,
-			})
-		}
-		dst.Spec.Sidecars = &sidecars
-	}
-	// ServiceAccountName
-	if src.Spec.ServiceAccountName != nil {
-		dst.Spec.ServiceAccountName = src.Spec.ServiceAccountName
-	}
-	return nil
-}
-
-// ConvertFrom converts from the Hub version (vbeta2) to this version.
-func (dst *RedisReplication) ConvertFrom(srcRaw conversion.Hub) error {
-	src := srcRaw.(*redisv1beta2.RedisReplication)
-
-	// ObjectMeta
-	dst.ObjectMeta = src.ObjectMeta
-
-	// Size
-	dst.Spec.Size = src.Spec.Size
-	// KubernetesConfig
-	dst.Spec.KubernetesConfig.KubernetesConfig = src.Spec.KubernetesConfig.KubernetesConfig
-	// RedisExporter
-	if src.Spec.RedisExporter != nil {
-		dst.Spec.RedisExporter = &RedisExporter{}
-		dst.Spec.RedisExporter.RedisExporter = src.Spec.RedisExporter.RedisExporter
-	}
-	// RedisConfig
-	if src.Spec.RedisConfig != nil {
-		dst.Spec.RedisConfig = &RedisConfig{}
-		dst.Spec.RedisConfig.RedisConfig = src.Spec.RedisConfig.RedisConfig
-	}
-	// Storage
-	if src.Spec.Storage != nil {
-		dst.Spec.Storage = &Storage{}
-		dst.Spec.Storage.VolumeClaimTemplate = src.Spec.Storage.VolumeClaimTemplate
-		dst.Spec.Storage.VolumeMount = src.Spec.Storage.VolumeMount
-	}
-	// NodeSelector
-	if src.Spec.NodeSelector != nil {
-		dst.Spec.NodeSelector = src.Spec.NodeSelector
-	}
-	//  PodSecurityContext >> SecurityContext
-	if src.Spec.PodSecurityContext != nil {
-		dst.Spec.SecurityContext = src.Spec.PodSecurityContext
-	}
-	// PriorityClassName
-	if src.Spec.PriorityClassName != "" {
-		dst.Spec.PriorityClassName = src.Spec.PriorityClassName
-	}
-	// Affinity
-	if src.Spec.Affinity != nil {
-		dst.Spec.Affinity = src.Spec.Affinity
-	}
-	// Tolerations
-	if src.Spec.Tolerations != nil {
-		dst.Spec.Tolerations = src.Spec.Tolerations
-	}
-	// TLS
-	if src.Spec.TLS != nil {
-		dst.Spec.TLS = &TLSConfig{}
-		dst.Spec.TLS.TLSConfig = src.Spec.TLS.TLSConfig
-	}
-	// ReadinessProbe
-	if src.Spec.ReadinessProbe != nil {
-		dst.Spec.ReadinessProbe = &Probe{}
-		dst.Spec.ReadinessProbe.Probe = src.Spec.ReadinessProbe.Probe
-	}
-	// LivenessProbe
-	if src.Spec.LivenessProbe != nil {
-		dst.Spec.ReadinessProbe = &Probe{}
-		dst.Spec.LivenessProbe.Probe = src.Spec.LivenessProbe.Probe
-	}
-	// Sidecars
-	if src.Spec.Sidecars != nil {
-		var sidecars []Sidecar
-		for _, sidecar := range *src.Spec.Sidecars {
-			sidecars = append(sidecars, Sidecar{
-				Sidecar: sidecar.Sidecar,
-			})
-		}
-		dst.Spec.Sidecars = &sidecars
-	}
-	// ServiceAccountName
-	if src.Spec.ServiceAccountName != nil {
-		dst.Spec.ServiceAccountName = src.Spec.ServiceAccountName
-	}
-	return nil
-}

api/v1beta1/redisreplication_types.go

@@ -1,60 +0,0 @@
-package v1beta1
-
-import (
-	corev1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-type RedisReplicationSpec struct {
-	Size              *int32                     `json:"clusterSize"`
-	KubernetesConfig  KubernetesConfig           `json:"kubernetesConfig"`
-	RedisExporter     *RedisExporter             `json:"redisExporter,omitempty"`
-	RedisConfig       *RedisConfig               `json:"redisConfig,omitempty"`
-	Storage           *Storage                   `json:"storage,omitempty"`
-	NodeSelector      map[string]string          `json:"nodeSelector,omitempty"`
-	SecurityContext   *corev1.PodSecurityContext `json:"securityContext,omitempty"`
-	PriorityClassName string                     `json:"priorityClassName,omitempty"`
-	Affinity          *corev1.Affinity           `json:"affinity,omitempty"`
-	Tolerations       *[]corev1.Toleration       `json:"tolerations,omitempty"`
-	TLS               *TLSConfig                 `json:"TLS,omitempty"`
-	// +kubebuilder:default:={initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}
-	ReadinessProbe *Probe `json:"readinessProbe,omitempty" protobuf:"bytes,11,opt,name=readinessProbe"`
-	// +kubebuilder:default:={initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}
-	LivenessProbe      *Probe     `json:"livenessProbe,omitempty" protobuf:"bytes,11,opt,name=livenessProbe"`
-	Sidecars           *[]Sidecar `json:"sidecars,omitempty"`
-	ServiceAccountName *string    `json:"serviceAccountName,omitempty"`
-}
-
-func (cr *RedisReplicationSpec) GetReplicationCounts(t string) int32 {
-	replica := cr.Size
-	return *replica
-}
-
-// RedisStatus defines the observed state of Redis
-type RedisReplicationStatus struct {
-}
-
-// +kubebuilder:object:root=true
-// +kubebuilder:subresource:status
-
-// Redis is the Schema for the redis API
-type RedisReplication struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	Spec   RedisReplicationSpec   `json:"spec"`
-	Status RedisReplicationStatus `json:"status,omitempty"`
-}
-
-// +kubebuilder:object:root=true
-
-// RedisList contains a list of Redis
-type RedisReplicationList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata,omitempty"`
-	Items           []RedisReplication `json:"items"`
-}
-
-func init() {
-	SchemeBuilder.Register(&RedisReplication{}, &RedisReplicationList{})
-}

api/v1beta1/redissentinel_conversion.go

@@ -1,142 +0,0 @@
-package v1beta1
-
-import (
-	redisv1beta2 "github.com/OT-CONTAINER-KIT/redis-operator/api/v1beta2"
-	"sigs.k8s.io/controller-runtime/pkg/conversion"
-)
-
-// ConvertTo converts this RedisSentinel to the Hub version (v1beta2).
-func (src *RedisSentinel) ConvertTo(dstRaw conversion.Hub) error {
-	dst := dstRaw.(*redisv1beta2.RedisSentinel)
-
-	// ObjectMeta
-	dst.ObjectMeta = src.ObjectMeta
-
-	// Size
-	dst.Spec.Size = src.Spec.Size
-	// KubernetesConfig
-	dst.Spec.KubernetesConfig.KubernetesConfig = src.Spec.KubernetesConfig.KubernetesConfig
-	// RedisSentinelConfig
-	if src.Spec.RedisSentinelConfig != nil {
-		dst.Spec.RedisSentinelConfig = &redisv1beta2.RedisSentinelConfig{}
-		dst.Spec.RedisSentinelConfig.RedisSentinelConfig = src.Spec.RedisSentinelConfig.RedisSentinelConfig
-	}
-	// NodeSelector
-	if src.Spec.NodeSelector != nil {
-		dst.Spec.NodeSelector = src.Spec.NodeSelector
-	}
-	// SecurityContext >> PodSecurityContext
-	if src.Spec.SecurityContext != nil {
-		dst.Spec.PodSecurityContext = src.Spec.SecurityContext
-	}
-	// PriorityClassName
-	if src.Spec.PriorityClassName != "" {
-		dst.Spec.PriorityClassName = src.Spec.PriorityClassName
-	}
-	// Affinity
-	if src.Spec.Affinity != nil {
-		dst.Spec.Affinity = src.Spec.Affinity
-	}
-	// Tolerations
-	if src.Spec.Tolerations != nil {
-		dst.Spec.Tolerations = src.Spec.Tolerations
-	}
-	// TLS
-	if src.Spec.TLS != nil {
-		dst.Spec.TLS = &redisv1beta2.TLSConfig{}
-		dst.Spec.TLS.TLSConfig = src.Spec.TLS.TLSConfig
-	}
-	// ReadinessProbe
-	if src.Spec.ReadinessProbe != nil {
-		dst.Spec.ReadinessProbe = &redisv1beta2.Probe{}
-		dst.Spec.ReadinessProbe.Probe = src.Spec.ReadinessProbe.Probe
-	}
-	// LivenessProbe
-	if src.Spec.LivenessProbe != nil {
-		dst.Spec.ReadinessProbe = &redisv1beta2.Probe{}
-		dst.Spec.LivenessProbe.Probe = src.Spec.LivenessProbe.Probe
-	}
-	// Sidecars
-	if src.Spec.Sidecars != nil {
-		var sidecars []redisv1beta2.Sidecar
-		for _, sidecar := range *src.Spec.Sidecars {
-			sidecars = append(sidecars, redisv1beta2.Sidecar{
-				Sidecar: sidecar.Sidecar,
-			})
-		}
-		dst.Spec.Sidecars = &sidecars
-	}
-	// ServiceAccountName
-	if src.Spec.ServiceAccountName != nil {
-		dst.Spec.ServiceAccountName = src.Spec.ServiceAccountName
-	}
-	return nil
-}
-
-// ConvertFrom converts from the Hub version (vbeta2) to this version.
-func (dst *RedisSentinel) ConvertFrom(srcRaw conversion.Hub) error {
-	src := srcRaw.(*redisv1beta2.RedisSentinel)
-
-	// ObjectMeta
-	dst.ObjectMeta = src.ObjectMeta
-
-	// Size
-	dst.Spec.Size = src.Spec.Size
-	// KubernetesConfig
-	dst.Spec.KubernetesConfig.KubernetesConfig = src.Spec.KubernetesConfig.KubernetesConfig
-	// RedisSentinelConfig
-	if src.Spec.RedisSentinelConfig != nil {
-		dst.Spec.RedisSentinelConfig = &RedisSentinelConfig{}
-		dst.Spec.RedisSentinelConfig.RedisSentinelConfig = src.Spec.RedisSentinelConfig.RedisSentinelConfig
-	}
-	// NodeSelector
-	if src.Spec.NodeSelector != nil {
-		dst.Spec.NodeSelector = src.Spec.NodeSelector
-	}
-	//  PodSecurityContext >> SecurityContext
-	if src.Spec.PodSecurityContext != nil {
-		dst.Spec.SecurityContext = src.Spec.PodSecurityContext
-	}
-	// PriorityClassName
-	if src.Spec.PriorityClassName != "" {
-		dst.Spec.PriorityClassName = src.Spec.PriorityClassName
-	}
-	// Affinity
-	if src.Spec.Affinity != nil {
-		dst.Spec.Affinity = src.Spec.Affinity
-	}
-	// Tolerations
-	if src.Spec.Tolerations != nil {
-		dst.Spec.Tolerations = src.Spec.Tolerations
-	}
-	// TLS
-	if src.Spec.TLS != nil {
-		dst.Spec.TLS = &TLSConfig{}
-		dst.Spec.TLS.TLSConfig = src.Spec.TLS.TLSConfig
-	}
-	// ReadinessProbe
-	if src.Spec.ReadinessProbe != nil {
-		dst.Spec.ReadinessProbe = &Probe{}
-		dst.Spec.ReadinessProbe.Probe = src.Spec.ReadinessProbe.Probe
-	}
-	// LivenessProbe
-	if src.Spec.LivenessProbe != nil {
-		dst.Spec.ReadinessProbe = &Probe{}
-		dst.Spec.LivenessProbe.Probe = src.Spec.LivenessProbe.Probe
-	}
-	// Sidecars
-	if src.Spec.Sidecars != nil {
-		var sidecars []Sidecar
-		for _, sidecar := range *src.Spec.Sidecars {
-			sidecars = append(sidecars, Sidecar{
-				Sidecar: sidecar.Sidecar,
-			})
-		}
-		dst.Spec.Sidecars = &sidecars
-	}
-	// ServiceAccountName
-	if src.Spec.ServiceAccountName != nil {
-		dst.Spec.ServiceAccountName = src.Spec.ServiceAccountName
-	}
-	return nil
-}

api/v1beta1/redissentinel_types.go

@@ -1,66 +0,0 @@
-package v1beta1
-
-import (
-	common "github.com/OT-CONTAINER-KIT/redis-operator/api"
-	corev1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-type RedisSentinelSpec struct {
-	// +kubebuilder:validation:Minimum=1
-	// +kubebuilder:validation:Default=3
-	// +kubebuilder:validation:Not=2
-	Size                *int32                           `json:"clusterSize"`
-	KubernetesConfig    KubernetesConfig                 `json:"kubernetesConfig"`
-	RedisSentinelConfig *RedisSentinelConfig             `json:"redisSentinelConfig,omitempty"`
-	NodeSelector        map[string]string                `json:"nodeSelector,omitempty"`
-	SecurityContext     *corev1.PodSecurityContext       `json:"securityContext,omitempty"`
-	PriorityClassName   string                           `json:"priorityClassName,omitempty"`
-	Affinity            *corev1.Affinity                 `json:"affinity,omitempty"`
-	Tolerations         *[]corev1.Toleration             `json:"tolerations,omitempty"`
-	TLS                 *TLSConfig                       `json:"TLS,omitempty"`
-	PodDisruptionBudget *common.RedisPodDisruptionBudget `json:"pdb,omitempty"`
-	// +kubebuilder:default:={initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}
-	ReadinessProbe *Probe `json:"readinessProbe,omitempty" protobuf:"bytes,11,opt,name=readinessProbe"`
-	// +kubebuilder:default:={initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}
-	LivenessProbe      *Probe     `json:"livenessProbe,omitempty" protobuf:"bytes,11,opt,name=livenessProbe"`
-	Sidecars           *[]Sidecar `json:"sidecars,omitempty"`
-	ServiceAccountName *string    `json:"serviceAccountName,omitempty"`
-}
-
-func (cr *RedisSentinelSpec) GetSentinelCounts(t string) int32 {
-	replica := cr.Size
-	return *replica
-}
-
-type RedisSentinelConfig struct {
-	common.RedisSentinelConfig `json:",inline"`
-}
-
-type RedisSentinelStatus struct {
-}
-
-// +kubebuilder:object:root=true
-// +kubebuilder:subresource:status
-
-// Redis is the Schema for the redis API
-type RedisSentinel struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	Spec   RedisSentinelSpec   `json:"spec"`
-	Status RedisSentinelStatus `json:"status,omitempty"`
-}
-
-// +kubebuilder:object:root=true
-
-// RedisList contains a list of Redis
-type RedisSentinelList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata,omitempty"`
-	Items           []RedisSentinel `json:"items"`
-}
-
-func init() {
-	SchemeBuilder.Register(&RedisSentinel{}, &RedisSentinelList{})
-}

api/v1beta1/zz_generated.deepcopy.go

@@ -1,880 +0,0 @@
-//go:build !ignore_autogenerated
-// +build !ignore_autogenerated
-
-/*
-Copyright 2020 Opstree Solutions.
-
-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 controller-gen. DO NOT EDIT.
-
-package v1beta1
-
-import (
-	"github.com/OT-CONTAINER-KIT/redis-operator/api"
-	"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 *ExistingPasswordSecret) DeepCopyInto(out *ExistingPasswordSecret) {
-	*out = *in
-	if in.Name != nil {
-		in, out := &in.Name, &out.Name
-		*out = new(string)
-		**out = **in
-	}
-	if in.Key != nil {
-		in, out := &in.Key, &out.Key
-		*out = new(string)
-		**out = **in
-	}
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExistingPasswordSecret.
-func (in *ExistingPasswordSecret) DeepCopy() *ExistingPasswordSecret {
-	if in == nil {
-		return nil
-	}
-	out := new(ExistingPasswordSecret)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *KubernetesConfig) DeepCopyInto(out *KubernetesConfig) {
-	*out = *in
-	in.KubernetesConfig.DeepCopyInto(&out.KubernetesConfig)
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KubernetesConfig.
-func (in *KubernetesConfig) DeepCopy() *KubernetesConfig {
-	if in == nil {
-		return nil
-	}
-	out := new(KubernetesConfig)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *Probe) DeepCopyInto(out *Probe) {
-	*out = *in
-	out.Probe = in.Probe
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Probe.
-func (in *Probe) DeepCopy() *Probe {
-	if in == nil {
-		return nil
-	}
-	out := new(Probe)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *Redis) DeepCopyInto(out *Redis) {
-	*out = *in
-	out.TypeMeta = in.TypeMeta
-	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
-	in.Spec.DeepCopyInto(&out.Spec)
-	out.Status = in.Status
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Redis.
-func (in *Redis) DeepCopy() *Redis {
-	if in == nil {
-		return nil
-	}
-	out := new(Redis)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
-func (in *Redis) 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 *RedisCluster) DeepCopyInto(out *RedisCluster) {
-	*out = *in
-	out.TypeMeta = in.TypeMeta
-	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
-	in.Spec.DeepCopyInto(&out.Spec)
-	out.Status = in.Status
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisCluster.
-func (in *RedisCluster) DeepCopy() *RedisCluster {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisCluster)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
-func (in *RedisCluster) 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 *RedisClusterList) DeepCopyInto(out *RedisClusterList) {
-	*out = *in
-	out.TypeMeta = in.TypeMeta
-	in.ListMeta.DeepCopyInto(&out.ListMeta)
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]RedisCluster, len(*in))
-		for i := range *in {
-			(*in)[i].DeepCopyInto(&(*out)[i])
-		}
-	}
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisClusterList.
-func (in *RedisClusterList) DeepCopy() *RedisClusterList {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisClusterList)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
-func (in *RedisClusterList) 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 *RedisClusterSpec) DeepCopyInto(out *RedisClusterSpec) {
-	*out = *in
-	if in.Size != nil {
-		in, out := &in.Size, &out.Size
-		*out = new(int32)
-		**out = **in
-	}
-	in.KubernetesConfig.DeepCopyInto(&out.KubernetesConfig)
-	if in.ClusterVersion != nil {
-		in, out := &in.ClusterVersion, &out.ClusterVersion
-		*out = new(string)
-		**out = **in
-	}
-	in.RedisLeader.DeepCopyInto(&out.RedisLeader)
-	in.RedisFollower.DeepCopyInto(&out.RedisFollower)
-	if in.RedisExporter != nil {
-		in, out := &in.RedisExporter, &out.RedisExporter
-		*out = new(RedisExporter)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.Storage != nil {
-		in, out := &in.Storage, &out.Storage
-		*out = new(Storage)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.SecurityContext != nil {
-		in, out := &in.SecurityContext, &out.SecurityContext
-		*out = new(v1.PodSecurityContext)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.Resources != nil {
-		in, out := &in.Resources, &out.Resources
-		*out = new(v1.ResourceRequirements)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.TLS != nil {
-		in, out := &in.TLS, &out.TLS
-		*out = new(TLSConfig)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.Sidecars != nil {
-		in, out := &in.Sidecars, &out.Sidecars
-		*out = new([]Sidecar)
-		if **in != nil {
-			in, out := *in, *out
-			*out = make([]Sidecar, len(*in))
-			for i := range *in {
-				(*in)[i].DeepCopyInto(&(*out)[i])
-			}
-		}
-	}
-	if in.ServiceAccountName != nil {
-		in, out := &in.ServiceAccountName, &out.ServiceAccountName
-		*out = new(string)
-		**out = **in
-	}
-	if in.PersistenceEnabled != nil {
-		in, out := &in.PersistenceEnabled, &out.PersistenceEnabled
-		*out = new(bool)
-		**out = **in
-	}
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisClusterSpec.
-func (in *RedisClusterSpec) DeepCopy() *RedisClusterSpec {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisClusterSpec)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *RedisClusterStatus) DeepCopyInto(out *RedisClusterStatus) {
-	*out = *in
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisClusterStatus.
-func (in *RedisClusterStatus) DeepCopy() *RedisClusterStatus {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisClusterStatus)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *RedisConfig) DeepCopyInto(out *RedisConfig) {
-	*out = *in
-	in.RedisConfig.DeepCopyInto(&out.RedisConfig)
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisConfig.
-func (in *RedisConfig) DeepCopy() *RedisConfig {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisConfig)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *RedisExporter) DeepCopyInto(out *RedisExporter) {
-	*out = *in
-	in.RedisExporter.DeepCopyInto(&out.RedisExporter)
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisExporter.
-func (in *RedisExporter) DeepCopy() *RedisExporter {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisExporter)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *RedisFollower) DeepCopyInto(out *RedisFollower) {
-	*out = *in
-	in.RedisFollower.DeepCopyInto(&out.RedisFollower)
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisFollower.
-func (in *RedisFollower) DeepCopy() *RedisFollower {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisFollower)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *RedisLeader) DeepCopyInto(out *RedisLeader) {
-	*out = *in
-	in.RedisLeader.DeepCopyInto(&out.RedisLeader)
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisLeader.
-func (in *RedisLeader) DeepCopy() *RedisLeader {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisLeader)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *RedisList) DeepCopyInto(out *RedisList) {
-	*out = *in
-	out.TypeMeta = in.TypeMeta
-	in.ListMeta.DeepCopyInto(&out.ListMeta)
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]Redis, len(*in))
-		for i := range *in {
-			(*in)[i].DeepCopyInto(&(*out)[i])
-		}
-	}
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisList.
-func (in *RedisList) DeepCopy() *RedisList {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisList)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
-func (in *RedisList) 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 *RedisReplication) DeepCopyInto(out *RedisReplication) {
-	*out = *in
-	out.TypeMeta = in.TypeMeta
-	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
-	in.Spec.DeepCopyInto(&out.Spec)
-	out.Status = in.Status
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisReplication.
-func (in *RedisReplication) DeepCopy() *RedisReplication {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisReplication)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
-func (in *RedisReplication) 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 *RedisReplicationList) DeepCopyInto(out *RedisReplicationList) {
-	*out = *in
-	out.TypeMeta = in.TypeMeta
-	in.ListMeta.DeepCopyInto(&out.ListMeta)
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]RedisReplication, len(*in))
-		for i := range *in {
-			(*in)[i].DeepCopyInto(&(*out)[i])
-		}
-	}
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisReplicationList.
-func (in *RedisReplicationList) DeepCopy() *RedisReplicationList {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisReplicationList)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
-func (in *RedisReplicationList) 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 *RedisReplicationSpec) DeepCopyInto(out *RedisReplicationSpec) {
-	*out = *in
-	if in.Size != nil {
-		in, out := &in.Size, &out.Size
-		*out = new(int32)
-		**out = **in
-	}
-	in.KubernetesConfig.DeepCopyInto(&out.KubernetesConfig)
-	if in.RedisExporter != nil {
-		in, out := &in.RedisExporter, &out.RedisExporter
-		*out = new(RedisExporter)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.RedisConfig != nil {
-		in, out := &in.RedisConfig, &out.RedisConfig
-		*out = new(RedisConfig)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.Storage != nil {
-		in, out := &in.Storage, &out.Storage
-		*out = new(Storage)
-		(*in).DeepCopyInto(*out)
-	}
-	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
-		}
-	}
-	if in.SecurityContext != nil {
-		in, out := &in.SecurityContext, &out.SecurityContext
-		*out = new(v1.PodSecurityContext)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.Affinity != nil {
-		in, out := &in.Affinity, &out.Affinity
-		*out = new(v1.Affinity)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.Tolerations != nil {
-		in, out := &in.Tolerations, &out.Tolerations
-		*out = new([]v1.Toleration)
-		if **in != nil {
-			in, out := *in, *out
-			*out = make([]v1.Toleration, len(*in))
-			for i := range *in {
-				(*in)[i].DeepCopyInto(&(*out)[i])
-			}
-		}
-	}
-	if in.TLS != nil {
-		in, out := &in.TLS, &out.TLS
-		*out = new(TLSConfig)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.ReadinessProbe != nil {
-		in, out := &in.ReadinessProbe, &out.ReadinessProbe
-		*out = new(Probe)
-		**out = **in
-	}
-	if in.LivenessProbe != nil {
-		in, out := &in.LivenessProbe, &out.LivenessProbe
-		*out = new(Probe)
-		**out = **in
-	}
-	if in.Sidecars != nil {
-		in, out := &in.Sidecars, &out.Sidecars
-		*out = new([]Sidecar)
-		if **in != nil {
-			in, out := *in, *out
-			*out = make([]Sidecar, len(*in))
-			for i := range *in {
-				(*in)[i].DeepCopyInto(&(*out)[i])
-			}
-		}
-	}
-	if in.ServiceAccountName != nil {
-		in, out := &in.ServiceAccountName, &out.ServiceAccountName
-		*out = new(string)
-		**out = **in
-	}
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisReplicationSpec.
-func (in *RedisReplicationSpec) DeepCopy() *RedisReplicationSpec {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisReplicationSpec)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *RedisReplicationStatus) DeepCopyInto(out *RedisReplicationStatus) {
-	*out = *in
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisReplicationStatus.
-func (in *RedisReplicationStatus) DeepCopy() *RedisReplicationStatus {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisReplicationStatus)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *RedisSentinel) DeepCopyInto(out *RedisSentinel) {
-	*out = *in
-	out.TypeMeta = in.TypeMeta
-	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
-	in.Spec.DeepCopyInto(&out.Spec)
-	out.Status = in.Status
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisSentinel.
-func (in *RedisSentinel) DeepCopy() *RedisSentinel {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisSentinel)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
-func (in *RedisSentinel) 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 *RedisSentinelConfig) DeepCopyInto(out *RedisSentinelConfig) {
-	*out = *in
-	in.RedisSentinelConfig.DeepCopyInto(&out.RedisSentinelConfig)
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisSentinelConfig.
-func (in *RedisSentinelConfig) DeepCopy() *RedisSentinelConfig {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisSentinelConfig)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *RedisSentinelList) DeepCopyInto(out *RedisSentinelList) {
-	*out = *in
-	out.TypeMeta = in.TypeMeta
-	in.ListMeta.DeepCopyInto(&out.ListMeta)
-	if in.Items != nil {
-		in, out := &in.Items, &out.Items
-		*out = make([]RedisSentinel, len(*in))
-		for i := range *in {
-			(*in)[i].DeepCopyInto(&(*out)[i])
-		}
-	}
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisSentinelList.
-func (in *RedisSentinelList) DeepCopy() *RedisSentinelList {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisSentinelList)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
-func (in *RedisSentinelList) 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 *RedisSentinelSpec) DeepCopyInto(out *RedisSentinelSpec) {
-	*out = *in
-	if in.Size != nil {
-		in, out := &in.Size, &out.Size
-		*out = new(int32)
-		**out = **in
-	}
-	in.KubernetesConfig.DeepCopyInto(&out.KubernetesConfig)
-	if in.RedisSentinelConfig != nil {
-		in, out := &in.RedisSentinelConfig, &out.RedisSentinelConfig
-		*out = new(RedisSentinelConfig)
-		(*in).DeepCopyInto(*out)
-	}
-	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
-		}
-	}
-	if in.SecurityContext != nil {
-		in, out := &in.SecurityContext, &out.SecurityContext
-		*out = new(v1.PodSecurityContext)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.Affinity != nil {
-		in, out := &in.Affinity, &out.Affinity
-		*out = new(v1.Affinity)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.Tolerations != nil {
-		in, out := &in.Tolerations, &out.Tolerations
-		*out = new([]v1.Toleration)
-		if **in != nil {
-			in, out := *in, *out
-			*out = make([]v1.Toleration, len(*in))
-			for i := range *in {
-				(*in)[i].DeepCopyInto(&(*out)[i])
-			}
-		}
-	}
-	if in.TLS != nil {
-		in, out := &in.TLS, &out.TLS
-		*out = new(TLSConfig)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.PodDisruptionBudget != nil {
-		in, out := &in.PodDisruptionBudget, &out.PodDisruptionBudget
-		*out = new(api.RedisPodDisruptionBudget)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.ReadinessProbe != nil {
-		in, out := &in.ReadinessProbe, &out.ReadinessProbe
-		*out = new(Probe)
-		**out = **in
-	}
-	if in.LivenessProbe != nil {
-		in, out := &in.LivenessProbe, &out.LivenessProbe
-		*out = new(Probe)
-		**out = **in
-	}
-	if in.Sidecars != nil {
-		in, out := &in.Sidecars, &out.Sidecars
-		*out = new([]Sidecar)
-		if **in != nil {
-			in, out := *in, *out
-			*out = make([]Sidecar, len(*in))
-			for i := range *in {
-				(*in)[i].DeepCopyInto(&(*out)[i])
-			}
-		}
-	}
-	if in.ServiceAccountName != nil {
-		in, out := &in.ServiceAccountName, &out.ServiceAccountName
-		*out = new(string)
-		**out = **in
-	}
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisSentinelSpec.
-func (in *RedisSentinelSpec) DeepCopy() *RedisSentinelSpec {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisSentinelSpec)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *RedisSentinelStatus) DeepCopyInto(out *RedisSentinelStatus) {
-	*out = *in
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisSentinelStatus.
-func (in *RedisSentinelStatus) DeepCopy() *RedisSentinelStatus {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisSentinelStatus)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *RedisSpec) DeepCopyInto(out *RedisSpec) {
-	*out = *in
-	in.KubernetesConfig.DeepCopyInto(&out.KubernetesConfig)
-	if in.RedisExporter != nil {
-		in, out := &in.RedisExporter, &out.RedisExporter
-		*out = new(RedisExporter)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.RedisConfig != nil {
-		in, out := &in.RedisConfig, &out.RedisConfig
-		*out = new(RedisConfig)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.Storage != nil {
-		in, out := &in.Storage, &out.Storage
-		*out = new(Storage)
-		(*in).DeepCopyInto(*out)
-	}
-	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
-		}
-	}
-	if in.SecurityContext != nil {
-		in, out := &in.SecurityContext, &out.SecurityContext
-		*out = new(v1.PodSecurityContext)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.Affinity != nil {
-		in, out := &in.Affinity, &out.Affinity
-		*out = new(v1.Affinity)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.Tolerations != nil {
-		in, out := &in.Tolerations, &out.Tolerations
-		*out = new([]v1.Toleration)
-		if **in != nil {
-			in, out := *in, *out
-			*out = make([]v1.Toleration, len(*in))
-			for i := range *in {
-				(*in)[i].DeepCopyInto(&(*out)[i])
-			}
-		}
-	}
-	if in.TLS != nil {
-		in, out := &in.TLS, &out.TLS
-		*out = new(TLSConfig)
-		(*in).DeepCopyInto(*out)
-	}
-	if in.ReadinessProbe != nil {
-		in, out := &in.ReadinessProbe, &out.ReadinessProbe
-		*out = new(Probe)
-		**out = **in
-	}
-	if in.LivenessProbe != nil {
-		in, out := &in.LivenessProbe, &out.LivenessProbe
-		*out = new(Probe)
-		**out = **in
-	}
-	if in.Sidecars != nil {
-		in, out := &in.Sidecars, &out.Sidecars
-		*out = new([]Sidecar)
-		if **in != nil {
-			in, out := *in, *out
-			*out = make([]Sidecar, len(*in))
-			for i := range *in {
-				(*in)[i].DeepCopyInto(&(*out)[i])
-			}
-		}
-	}
-	if in.ServiceAccountName != nil {
-		in, out := &in.ServiceAccountName, &out.ServiceAccountName
-		*out = new(string)
-		**out = **in
-	}
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisSpec.
-func (in *RedisSpec) DeepCopy() *RedisSpec {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisSpec)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *RedisStatus) DeepCopyInto(out *RedisStatus) {
-	*out = *in
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RedisStatus.
-func (in *RedisStatus) DeepCopy() *RedisStatus {
-	if in == nil {
-		return nil
-	}
-	out := new(RedisStatus)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *ServiceConfig) DeepCopyInto(out *ServiceConfig) {
-	*out = *in
-	if in.ServiceAnnotations != nil {
-		in, out := &in.ServiceAnnotations, &out.ServiceAnnotations
-		*out = make(map[string]string, len(*in))
-		for key, val := range *in {
-			(*out)[key] = val
-		}
-	}
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServiceConfig.
-func (in *ServiceConfig) DeepCopy() *ServiceConfig {
-	if in == nil {
-		return nil
-	}
-	out := new(ServiceConfig)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *Sidecar) DeepCopyInto(out *Sidecar) {
-	*out = *in
-	in.Sidecar.DeepCopyInto(&out.Sidecar)
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Sidecar.
-func (in *Sidecar) DeepCopy() *Sidecar {
-	if in == nil {
-		return nil
-	}
-	out := new(Sidecar)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *Storage) DeepCopyInto(out *Storage) {
-	*out = *in
-	in.Storage.DeepCopyInto(&out.Storage)
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Storage.
-func (in *Storage) DeepCopy() *Storage {
-	if in == nil {
-		return nil
-	}
-	out := new(Storage)
-	in.DeepCopyInto(out)
-	return out
-}
-
-// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
-func (in *TLSConfig) DeepCopyInto(out *TLSConfig) {
-	*out = *in
-	in.TLSConfig.DeepCopyInto(&out.TLSConfig)
-}
-
-// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TLSConfig.
-func (in *TLSConfig) DeepCopy() *TLSConfig {
-	if in == nil {
-		return nil
-	}
-	out := new(TLSConfig)
-	in.DeepCopyInto(out)
-	return out
-}

api/v1beta2/common_types.go

@@ -1,96 +0,0 @@
-/*
-Copyright 2020 Opstree Solutions.
-
-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.
-*/
-
-package v1beta2
-
-import (
-	common "github.com/OT-CONTAINER-KIT/redis-operator/api"
-	corev1 "k8s.io/api/core/v1"
-)
-
-// KubernetesConfig will be the JSON struct for Basic Redis Config
-type KubernetesConfig struct {
-	common.KubernetesConfig `json:",inline"`
-}
-
-// ServiceConfig define the type of service to be created and its annotations
-type ServiceConfig struct {
-	// +kubebuilder:validation:Enum=LoadBalancer;NodePort;ClusterIP
-	ServiceType        string            `json:"serviceType,omitempty"`
-	ServiceAnnotations map[string]string `json:"annotations,omitempty"`
-}
-
-// RedisConfig defines the external configuration of Redis
-type RedisConfig struct {
-	common.RedisConfig `json:",inline"`
-}
-
-// ExistingPasswordSecret is the struct to access the existing secret
-type ExistingPasswordSecret struct {
-	Name *string `json:"name,omitempty"`
-	Key  *string `json:"key,omitempty"`
-}
-
-// Storage is the inteface to add pvc and pv support in redis
-type Storage struct {
-	common.Storage `json:",inline"`
-}
-
-// Node-conf needs to be added only in redis cluster
-type ClusterStorage struct {
-	// +kubebuilder:default=false
-	NodeConfVolume              bool                         `json:"nodeConfVolume,omitempty"`
-	NodeConfVolumeClaimTemplate corev1.PersistentVolumeClaim `json:"nodeConfVolumeClaimTemplate,omitempty"`
-	common.Storage              `json:",inline"`
-}
-
-// RedisExporter interface will have the information for redis exporter related stuff
-type RedisExporter struct {
-	common.RedisExporter `json:",inline"`
-}
-
-// TLS Configuration for redis instances
-type TLSConfig struct {
-	common.TLSConfig `json:",inline"`
-}
-
-type ACLConfig struct {
-	Secret *corev1.SecretVolumeSource `json:"secret,omitempty"`
-}
-
-// Probe is a interface for ReadinessProbe and LivenessProbe
-type Probe struct {
-	common.Probe `json:",inline"`
-}
-
-// Sidecar for each Redis pods
-type Sidecar struct {
-	common.Sidecar `json:",inline"`
-	Volumes        *[]corev1.VolumeMount   `json:"mountPath,omitempty"`
-	Command        []string                `json:"command,omitempty" protobuf:"bytes,3,rep,name=command"`
-	Ports          *[]corev1.ContainerPort `json:"ports,omitempty" patchStrategy:"merge" patchMergeKey:"containerPort" protobuf:"bytes,6,rep,name=ports"`
-}
-
-// InitContainer for each Redis pods
-type InitContainer struct {
-	Enabled         *bool                        `json:"enabled,omitempty"`
-	Image           string                       `json:"image"`
-	ImagePullPolicy corev1.PullPolicy            `json:"imagePullPolicy,omitempty"`
-	Resources       *corev1.ResourceRequirements `json:"resources,omitempty"`
-	EnvVars         *[]corev1.EnvVar             `json:"env,omitempty"`
-	Command         []string                     `json:"command,omitempty"`
-	Args            []string                     `json:"args,omitempty"`
-}

api/v1beta2/redis_types.go

@@ -1,80 +0,0 @@
-/*
-Copyright 2020 Opstree Solutions.
-
-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.
-*/
-
-package v1beta2
-
-import (
-	corev1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-// EDIT THIS FILE!  THIS IS SCAFFOLDING FOR YOU TO OWN!
-// NOTE: json tags are required.  Any new fields you add must have json tags for the fields to be serialized.
-
-// RedisSpec defines the desired state of Redis
-type RedisSpec struct {
-	KubernetesConfig   KubernetesConfig           `json:"kubernetesConfig"`
-	RedisExporter      *RedisExporter             `json:"redisExporter,omitempty"`
-	RedisConfig        *RedisConfig               `json:"redisConfig,omitempty"`
-	Storage            *Storage                   `json:"storage,omitempty"`
-	NodeSelector       map[string]string          `json:"nodeSelector,omitempty"`
-	PodSecurityContext *corev1.PodSecurityContext `json:"podSecurityContext,omitempty"`
-	SecurityContext    *corev1.SecurityContext    `json:"securityContext,omitempty"`
-	PriorityClassName  string                     `json:"priorityClassName,omitempty"`
-	Affinity           *corev1.Affinity           `json:"affinity,omitempty"`
-	Tolerations        *[]corev1.Toleration       `json:"tolerations,omitempty"`
-	TLS                *TLSConfig                 `json:"TLS,omitempty"`
-	ACL                *ACLConfig                 `json:"acl,omitempty"`
-	// +kubebuilder:default:={initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}
-	ReadinessProbe *Probe `json:"readinessProbe,omitempty" protobuf:"bytes,11,opt,name=readinessProbe"`
-	// +kubebuilder:default:={initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}
-	LivenessProbe                 *Probe           `json:"livenessProbe,omitempty" protobuf:"bytes,11,opt,name=livenessProbe"`
-	InitContainer                 *InitContainer   `json:"initContainer,omitempty"`
-	Sidecars                      *[]Sidecar       `json:"sidecars,omitempty"`
-	ServiceAccountName            *string          `json:"serviceAccountName,omitempty"`
-	TerminationGracePeriodSeconds *int64           `json:"terminationGracePeriodSeconds,omitempty" protobuf:"varint,4,opt,name=terminationGracePeriodSeconds"`
-	EnvVars                       *[]corev1.EnvVar `json:"env,omitempty"`
-}
-
-// RedisStatus defines the observed state of Redis
-type RedisStatus struct {
-}
-
-// +kubebuilder:object:root=true
-// +kubebuilder:subresource:status
-// +kubebuilder:storageversion
-
-// Redis is the Schema for the redis API
-type Redis struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	Spec   RedisSpec   `json:"spec"`
-	Status RedisStatus `json:"status,omitempty"`
-}
-
-// +kubebuilder:object:root=true
-
-// RedisList contains a list of Redis
-type RedisList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata,omitempty"`
-	Items           []Redis `json:"items"`
-}
-
-func init() {
-	SchemeBuilder.Register(&Redis{}, &RedisList{})
-}

api/v1beta2/rediscluster_types.go

@@ -1,115 +0,0 @@
-/*
-Copyright 2020 Opstree Solutions.
-
-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.
-*/
-
-package v1beta2
-
-import (
-	common "github.com/OT-CONTAINER-KIT/redis-operator/api"
-	status "github.com/OT-CONTAINER-KIT/redis-operator/api/status"
-	corev1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-// RedisClusterSpec defines the desired state of RedisCluster
-type RedisClusterSpec struct {
-	Size             *int32           `json:"clusterSize"`
-	KubernetesConfig KubernetesConfig `json:"kubernetesConfig"`
-	// +kubebuilder:default:=v7
-	ClusterVersion *string `json:"clusterVersion,omitempty"`
-	// +kubebuilder:default:={livenessProbe:{initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}, readinessProbe:{initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}}
-	RedisLeader RedisLeader `json:"redisLeader,omitempty"`
-	// +kubebuilder:default:={livenessProbe:{initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}, readinessProbe:{initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}}
-	RedisFollower      RedisFollower                `json:"redisFollower,omitempty"`
-	RedisExporter      *RedisExporter               `json:"redisExporter,omitempty"`
-	Storage            *ClusterStorage              `json:"storage,omitempty"`
-	PodSecurityContext *corev1.PodSecurityContext   `json:"podSecurityContext,omitempty"`
-	PriorityClassName  string                       `json:"priorityClassName,omitempty"`
-	Resources          *corev1.ResourceRequirements `json:"resources,omitempty"`
-	TLS                *TLSConfig                   `json:"TLS,omitempty"`
-	ACL                *ACLConfig                   `json:"acl,omitempty"`
-	InitContainer      *InitContainer               `json:"initContainer,omitempty"`
-	Sidecars           *[]Sidecar                   `json:"sidecars,omitempty"`
-	ServiceAccountName *string                      `json:"serviceAccountName,omitempty"`
-	PersistenceEnabled *bool                        `json:"persistenceEnabled,omitempty"`
-	EnvVars            *[]corev1.EnvVar             `json:"env,omitempty"`
-}
-
-func (cr *RedisClusterSpec) GetReplicaCounts(t string) int32 {
-	replica := cr.Size
-	if t == "leader" && cr.RedisLeader.Replicas != nil {
-		replica = cr.RedisLeader.Replicas
-	} else if t == "follower" && cr.RedisFollower.Replicas != nil {
-		replica = cr.RedisFollower.Replicas
-	}
-	return *replica
-}
-
-// RedisLeader interface will have the redis leader configuration
-type RedisLeader struct {
-	common.RedisLeader            `json:",inline"`
-	SecurityContext               *corev1.SecurityContext `json:"securityContext,omitempty"`
-	TerminationGracePeriodSeconds *int64                  `json:"terminationGracePeriodSeconds,omitempty" protobuf:"varint,4,opt,name=terminationGracePeriodSeconds"`
-}
-
-// RedisFollower interface will have the redis follower configuration
-type RedisFollower struct {
-	common.RedisFollower          `json:",inline"`
-	SecurityContext               *corev1.SecurityContext `json:"securityContext,omitempty"`
-	TerminationGracePeriodSeconds *int64                  `json:"terminationGracePeriodSeconds,omitempty" protobuf:"varint,4,opt,name=terminationGracePeriodSeconds"`
-}
-
-// RedisClusterStatus defines the observed state of RedisCluster
-// +kubebuilder:subresource:status
-type RedisClusterStatus struct {
-	State  status.RedisClusterState `json:"state,omitempty"`
-	Reason string                   `json:"reason,omitempty"`
-	// +kubebuilder:default=0
-	ReadyLeaderReplicas int32 `json:"readyLeaderReplicas,omitempty"`
-	// +kubebuilder:default=0
-	ReadyFollowerReplicas int32 `json:"readyFollowerReplicas,omitempty"`
-}
-
-// +kubebuilder:object:root=true
-// +kubebuilder:subresource:status
-// +kubebuilder:storageversion
-// +kubebuilder:printcolumn:name="ClusterSize",type=integer,JSONPath=`.spec.clusterSize`,description=Current cluster node count
-// +kubebuilder:printcolumn:name="ReadyLeaderReplicas",type="integer",JSONPath=".status.readyLeaderReplicas",description="Number of ready leader replicas"
-// +kubebuilder:printcolumn:name="ReadyFollowerReplicas",type="integer",JSONPath=".status.readyFollowerReplicas",description="Number of ready follower replicas"
-// +kubebuilder:printcolumn:name="State",type="string",JSONPath=".status.state",description="The current state of the Redis Cluster",priority=1
-// +kubebuilder:printcolumn:name="Age",type=date,JSONPath=`.metadata.creationTimestamp`,description="Age of Cluster",priority=1
-// +kubebuilder:printcolumn:name="Reason",type="string",JSONPath=".status.reason",description="The reason for the current state",priority=1
-
-// RedisCluster is the Schema for the redisclusters API
-type RedisCluster struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	Spec   RedisClusterSpec   `json:"spec"`
-	Status RedisClusterStatus `json:"status,omitempty"`
-}
-
-//+kubebuilder:object:root=true
-
-// RedisClusterList contains a list of RedisCluster
-type RedisClusterList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata,omitempty"`
-	Items           []RedisCluster `json:"items"`
-}
-
-func init() {
-	SchemeBuilder.Register(&RedisCluster{}, &RedisClusterList{})
-}

api/v1beta2/redisreplication_types.go

@@ -1,66 +0,0 @@
-package v1beta2
-
-import (
-	corev1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-type RedisReplicationSpec struct {
-	Size               *int32                     `json:"clusterSize"`
-	KubernetesConfig   KubernetesConfig           `json:"kubernetesConfig"`
-	RedisExporter      *RedisExporter             `json:"redisExporter,omitempty"`
-	RedisConfig        *RedisConfig               `json:"redisConfig,omitempty"`
-	Storage            *Storage                   `json:"storage,omitempty"`
-	NodeSelector       map[string]string          `json:"nodeSelector,omitempty"`
-	PodSecurityContext *corev1.PodSecurityContext `json:"podSecurityContext,omitempty"`
-	SecurityContext    *corev1.SecurityContext    `json:"securityContext,omitempty"`
-	PriorityClassName  string                     `json:"priorityClassName,omitempty"`
-	Affinity           *corev1.Affinity           `json:"affinity,omitempty"`
-	Tolerations        *[]corev1.Toleration       `json:"tolerations,omitempty"`
-	TLS                *TLSConfig                 `json:"TLS,omitempty"`
-	ACL                *ACLConfig                 `json:"acl,omitempty"`
-	// +kubebuilder:default:={initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}
-	ReadinessProbe *Probe `json:"readinessProbe,omitempty" protobuf:"bytes,11,opt,name=readinessProbe"`
-	// +kubebuilder:default:={initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}
-	LivenessProbe                 *Probe           `json:"livenessProbe,omitempty" protobuf:"bytes,11,opt,name=livenessProbe"`
-	InitContainer                 *InitContainer   `json:"initContainer,omitempty"`
-	Sidecars                      *[]Sidecar       `json:"sidecars,omitempty"`
-	ServiceAccountName            *string          `json:"serviceAccountName,omitempty"`
-	TerminationGracePeriodSeconds *int64           `json:"terminationGracePeriodSeconds,omitempty" protobuf:"varint,4,opt,name=terminationGracePeriodSeconds"`
-	EnvVars                       *[]corev1.EnvVar `json:"env,omitempty"`
-}
-
-func (cr *RedisReplicationSpec) GetReplicationCounts(t string) int32 {
-	replica := cr.Size
-	return *replica
-}
-
-// RedisStatus defines the observed state of Redis
-type RedisReplicationStatus struct {
-}
-
-// +kubebuilder:object:root=true
-// +kubebuilder:subresource:status
-// +kubebuilder:storageversion
-
-// Redis is the Schema for the redis API
-type RedisReplication struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	Spec   RedisReplicationSpec   `json:"spec"`
-	Status RedisReplicationStatus `json:"status,omitempty"`
-}
-
-// +kubebuilder:object:root=true
-
-// RedisList contains a list of Redis
-type RedisReplicationList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata,omitempty"`
-	Items           []RedisReplication `json:"items"`
-}
-
-func init() {
-	SchemeBuilder.Register(&RedisReplication{}, &RedisReplicationList{})
-}

api/v1beta2/redissentinel_types.go

@@ -1,71 +0,0 @@
-package v1beta2
-
-import (
-	common "github.com/OT-CONTAINER-KIT/redis-operator/api"
-	corev1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-type RedisSentinelSpec struct {
-	// +kubebuilder:validation:Minimum=1
-	// +kubebuilder:default=3
-	Size                *int32                           `json:"clusterSize"`
-	KubernetesConfig    KubernetesConfig                 `json:"kubernetesConfig"`
-	RedisExporter       *RedisExporter                   `json:"redisExporter,omitempty"`
-	RedisSentinelConfig *RedisSentinelConfig             `json:"redisSentinelConfig,omitempty"`
-	NodeSelector        map[string]string                `json:"nodeSelector,omitempty"`
-	PodSecurityContext  *corev1.PodSecurityContext       `json:"podSecurityContext,omitempty"`
-	SecurityContext     *corev1.SecurityContext          `json:"securityContext,omitempty"`
-	PriorityClassName   string                           `json:"priorityClassName,omitempty"`
-	Affinity            *corev1.Affinity                 `json:"affinity,omitempty"`
-	Tolerations         *[]corev1.Toleration             `json:"tolerations,omitempty"`
-	TLS                 *TLSConfig                       `json:"TLS,omitempty"`
-	PodDisruptionBudget *common.RedisPodDisruptionBudget `json:"pdb,omitempty"`
-	// +kubebuilder:default:={initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}
-	ReadinessProbe *Probe `json:"readinessProbe,omitempty" protobuf:"bytes,11,opt,name=readinessProbe"`
-	// +kubebuilder:default:={initialDelaySeconds: 1, timeoutSeconds: 1, periodSeconds: 10, successThreshold: 1, failureThreshold:3}
-	LivenessProbe                 *Probe           `json:"livenessProbe,omitempty" protobuf:"bytes,11,opt,name=livenessProbe"`
-	InitContainer                 *InitContainer   `json:"initContainer,omitempty"`
-	Sidecars                      *[]Sidecar       `json:"sidecars,omitempty"`
-	ServiceAccountName            *string          `json:"serviceAccountName,omitempty"`
-	TerminationGracePeriodSeconds *int64           `json:"terminationGracePeriodSeconds,omitempty" protobuf:"varint,4,opt,name=terminationGracePeriodSeconds"`
-	EnvVars                       *[]corev1.EnvVar `json:"env,omitempty"`
-}
-
-func (cr *RedisSentinelSpec) GetSentinelCounts(t string) int32 {
-	replica := cr.Size
-	return *replica
-}
-
-type RedisSentinelConfig struct {
-	common.RedisSentinelConfig `json:",inline"`
-}
-
-type RedisSentinelStatus struct {
-}
-
-// +kubebuilder:object:root=true
-// +kubebuilder:subresource:status
-//+kubebuilder:storageversion
-
-// Redis is the Schema for the redis API
-type RedisSentinel struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata,omitempty"`
-
-	Spec   RedisSentinelSpec   `json:"spec"`
-	Status RedisSentinelStatus `json:"status,omitempty"`
-}
-
-// +kubebuilder:object:root=true
-
-// RedisList contains a list of Redis
-type RedisSentinelList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata,omitempty"`
-	Items           []RedisSentinel `json:"items"`
-}
-
-func init() {
-	SchemeBuilder.Register(&RedisSentinel{}, &RedisSentinelList{})
-}

charts/redis-cluster/Chart.yaml

@@ -0,0 +1,21 @@
+apiVersion: v2
+name: redis-cluster
+description: Provides easy redis setup definitions for Kubernetes services, and deployment.
+version: 0.17.0
+appVersion: "0.17.0"
+home: https://github.com/ot-container-kit/redis-operator
+sources:
+  - https://github.com/ot-container-kit/redis-operator
+maintainers:
+  - name: iamabhishek-dubey
+  - name: sandy724
+  - name: shubham-cmyk
+keywords:
+- operator
+- redis
+- opstree
+- kubernetes
+- openshift
+- redis-exporter
+icon: https://github.com/OT-CONTAINER-KIT/redis-operator/raw/main/static/redis-operator-logo.svg
+type: application

charts/redis-cluster/README.md

@@ -0,0 +1,132 @@
+# redis
+
+Redis is a key-value based distributed database, this helm chart is for redis cluster setup. This helm chart needs [Redis Operator](../redis-operator) inside Kubernetes cluster. The redis cluster definition can be modified or changed by [values.yaml](./values.yaml).
+
+**Homepage:** <https://github.com/ot-container-kit/redis-operator>
+
+## Maintainers
+
+| Name | Email | Url |
+| ---- | ------ | --- |
+| iamabhishek-dubey |  |  |
+| sandy724 |  |  |
+| shubham-cmyk |  |  |
+
+## Pre-Requisities
+
+- Kubernetes 1.15+
+- Helm 3.X
+- Redis Operator 0.7.0
+
+## Source Code
+
+* <https://github.com/ot-container-kit/redis-operator>
+
+```shell
+helm repo add ot-helm https://ot-container-kit.github.io/helm-charts/
+
+helm install <my-release> ot-helm/redis-cluster \
+    --set redisCluster.clusterSize=3 --namespace <namespace>
+```
+
+Redis setup can be upgraded by using `helm upgrade` command:-
+
+```shell
+helm upgrade <my-release> ot-helm/redis-cluster --install \
+    --set redisCluster.clusterSize=5 --namespace <namespace>
+```
+
+For uninstalling the chart:-
+
+```shell
+helm delete <my-release> --namespace <namespace>
+```
+
+## Values
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| TLS.ca | string | `"ca.key"` |  |
+| TLS.cert | string | `"tls.crt"` |  |
+| TLS.key | string | `"tls.key"` |  |
+| TLS.secret.secretName | string | `""` |  |
+| acl.secret.secretName | string | `""` |  |
+| env | list | `[]` |  |
+| externalConfig.data | string | `"tcp-keepalive 400\nslowlog-max-len 158\nstream-node-max-bytes 2048\n"` |  |
+| externalConfig.enabled | bool | `false` |  |
+| externalService.enabled | bool | `false` |  |
+| externalService.port | int | `6379` |  |
+| externalService.serviceType | string | `"LoadBalancer"` |  |
+| initContainer.args | list | `[]` |  |
+| initContainer.command | list | `[]` |  |
+| initContainer.enabled | bool | `false` |  |
+| initContainer.env | list | `[]` |  |
+| initContainer.image | string | `""` |  |
+| initContainer.imagePullPolicy | string | `"IfNotPresent"` |  |
+| initContainer.resources | object | `{}` |  |
+| labels | object | `{}` |  |
+| podSecurityContext.fsGroup | int | `1000` |  |
+| podSecurityContext.runAsUser | int | `1000` |  |
+| priorityClassName | string | `""` |  |
+| redisCluster.clusterSize | int | `3` | Default number of replicas for both leader and follower when not explicitly set |
+| redisCluster.clusterVersion | string | `"v7"` |  |
+| redisCluster.enableMasterSlaveAntiAffinity | bool | `false` | Enable pod anti-affinity between leader and follower pods by adding the appropriate label. Notice that this requires the operator to have its mutating webhook enabled, otherwise it will only add an annotation to the RedisCluster CR. Default is false. |
+| redisCluster.follower.affinity | string | `nil` |  |
+| redisCluster.follower.livenessProbe | object | `{}` |  |
+| redisCluster.follower.nodeSelector | string | `nil` |  |
+| redisCluster.follower.pdb.enabled | bool | `false` |  |
+| redisCluster.follower.pdb.maxUnavailable | int | `1` |  |
+| redisCluster.follower.pdb.minAvailable | int | `1` |  |
+| redisCluster.follower.readinessProbe | object | `{}` |  |
+| redisCluster.follower.replicas | int | `3` | Number of Redis follower (slave) nodes. If not set, uses clusterSize value |
+| redisCluster.follower.securityContext | object | `{}` |  |
+| redisCluster.follower.serviceType | string | `"ClusterIP"` |  |
+| redisCluster.follower.tolerations | list | `[]` |  |
+| redisCluster.image | string | `"quay.io/opstree/redis"` |  |
+| redisCluster.imagePullPolicy | string | `"IfNotPresent"` |  |
+| redisCluster.imagePullSecrets | object | `{}` |  |
+| redisCluster.leader.affinity | object | `{}` |  |
+| redisCluster.leader.livenessProbe | object | `{}` |  |
+| redisCluster.leader.nodeSelector | string | `nil` |  |
+| redisCluster.leader.pdb.enabled | bool | `false` |  |
+| redisCluster.leader.pdb.maxUnavailable | int | `1` |  |
+| redisCluster.leader.pdb.minAvailable | int | `1` |  |
+| redisCluster.leader.readinessProbe | object | `{}` |  |
+| redisCluster.leader.replicas | int | `3` | Number of Redis leader (master) nodes. If not set, uses clusterSize value |
+| redisCluster.leader.securityContext | object | `{}` |  |
+| redisCluster.leader.serviceType | string | `"ClusterIP"` |  |
+| redisCluster.leader.tolerations | list | `[]` |  |
+| redisCluster.minReadySeconds | int | `0` |  |
+| redisCluster.name | string | `""` |  |
+| redisCluster.persistenceEnabled | bool | `true` |  |
+| redisCluster.recreateStatefulSetOnUpdateInvalid | bool | `false` | Some fields of statefulset are immutable, such as volumeClaimTemplates. When set to true, the operator will delete the statefulset and recreate it. Default is false. |
+| redisCluster.redisSecret.secretKey | string | `""` |  |
+| redisCluster.redisSecret.secretName | string | `""` |  |
+| redisCluster.resources | object | `{}` |  |
+| redisCluster.tag | string | `"v7.0.15"` |  |
+| redisExporter.enabled | bool | `false` |  |
+| redisExporter.env | list | `[]` |  |
+| redisExporter.image | string | `"quay.io/opstree/redis-exporter"` |  |
+| redisExporter.imagePullPolicy | string | `"IfNotPresent"` |  |
+| redisExporter.resources | object | `{}` |  |
+| redisExporter.securityContext | object | `{}` |  |
+| redisExporter.tag | string | `"v1.44.0"` |  |
+| serviceAccountName | string | `""` |  |
+| serviceMonitor.enabled | bool | `false` |  |
+| serviceMonitor.extraLabels | object | `{}` | extraLabels are added to the servicemonitor when enabled set to true |
+| serviceMonitor.interval | string | `"30s"` |  |
+| serviceMonitor.namespace | string | `"monitoring"` |  |
+| serviceMonitor.scrapeTimeout | string | `"10s"` |  |
+| sidecars.env | object | `{}` |  |
+| sidecars.image | string | `""` |  |
+| sidecars.imagePullPolicy | string | `"IfNotPresent"` |  |
+| sidecars.name | string | `""` |  |
+| sidecars.resources.limits.cpu | string | `"100m"` |  |
+| sidecars.resources.limits.memory | string | `"128Mi"` |  |
+| sidecars.resources.requests.cpu | string | `"50m"` |  |
+| sidecars.resources.requests.memory | string | `"64Mi"` |  |
+| storageSpec.nodeConfVolume | bool | `true` |  |
+| storageSpec.nodeConfVolumeClaimTemplate.spec.accessModes[0] | string | `"ReadWriteOnce"` |  |
+| storageSpec.nodeConfVolumeClaimTemplate.spec.resources.requests.storage | string | `"1Gi"` |  |
+| storageSpec.volumeClaimTemplate.spec.accessModes[0] | string | `"ReadWriteOnce"` |  |
+| storageSpec.volumeClaimTemplate.spec.resources.requests.storage | string | `"1Gi"` |  |

charts/redis-cluster/README.md.gotmpl

@@ -0,0 +1,45 @@
+# redis
+
+Redis is a key-value based distributed database, this helm chart is for redis cluster setup. This helm chart needs [Redis Operator](../redis-operator) inside Kubernetes cluster. The redis cluster definition can be modified or changed by [values.yaml](./values.yaml).
+
+**Homepage:** <https://github.com/ot-container-kit/redis-operator>
+
+## Maintainers
+
+| Name | Email | Url |
+| ---- | ------ | --- |
+| iamabhishek-dubey |  |  |
+| sandy724 |  |  |
+| shubham-cmyk |  |  |
+
+## Pre-Requisities
+
+- Kubernetes 1.15+
+- Helm 3.X
+- Redis Operator 0.7.0
+
+## Source Code
+
+* <https://github.com/ot-container-kit/redis-operator>
+
+```shell
+helm repo add ot-helm https://ot-container-kit.github.io/helm-charts/
+
+helm install <my-release> ot-helm/redis-cluster \
+    --set redisCluster.clusterSize=3 --namespace <namespace>
+```
+
+Redis setup can be upgraded by using `helm upgrade` command:-
+
+```shell
+helm upgrade <my-release> ot-helm/redis-cluster --install \
+    --set redisCluster.clusterSize=5 --namespace <namespace>
+```
+
+For uninstalling the chart:-
+
+```shell
+helm delete <my-release> --namespace <namespace>
+```
+
+{{ template "chart.valuesSection" . }}

charts/redis-cluster/templates/_helpers.tpl

@@ -0,0 +1,99 @@
+{{/* vim: set filetype=mustache: */}}
+
+{{/* Define common labels */}}
+{{- define "common.labels" -}}
+app.kubernetes.io/name: {{ .Values.redisCluster.name | default .Release.Name }}
+helm.sh/chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+app.kubernetes.io/managed-by: {{ .Release.Service }}
+app.kubernetes.io/instance: {{ .Values.redisCluster.name | default .Release.Name }}
+app.kubernetes.io/version: {{ .Chart.AppVersion }}
+app.kubernetes.io/component: middleware
+{{- if .Values.labels }}
+{{- range $labelkey, $labelvalue := .Values.labels }}
+{{ $labelkey}}: {{ $labelvalue }}
+{{- end }}
+{{- end }}
+{{- end -}}
+
+{{/* Helper for Redis Cluster (leader & follower) */}}
+{{- define "redis.role" -}}
+{{- if .affinity }}
+affinity:
+  {{- toYaml .affinity | nindent 2 }}
+{{- end }}
+{{- if .tolerations }}
+tolerations:
+  {{- toYaml .tolerations | nindent 2 }}
+{{- end }}
+{{- if .pdb.enabled  }}
+pdb:
+  enabled: {{ .pdb.enabled }}
+  maxUnavailable: {{ .pdb.maxUnavailable }}
+  minAvailable: {{ .pdb.minAvailable }}
+{{- end }}
+{{- if .nodeSelector }}
+nodeSelector:
+  {{- toYaml .nodeSelector | nindent 2 }}
+{{- end }}
+{{- if .securityContext }}
+securityContext:
+  {{- toYaml .securityContext | nindent 2 }}
+{{- end }}
+{{- if .livenessProbe }}
+livenessProbe:
+  {{- toYaml .livenessProbe | nindent 2 }}
+{{- end }}
+{{- if .readinessProbe }}
+readinessProbe:
+  {{- toYaml .readinessProbe | nindent 2 }}
+{{- end }}
+{{- end -}}
+
+{{/* Generate sidecar properties */}}
+{{- define "sidecar.properties" -}}
+{{- with .Values.sidecars }}
+name: {{ .name }}
+image: {{ .image }}
+{{- if .imagePullPolicy }}
+imagePullPolicy: {{ .imagePullPolicy }}
+{{- end }}
+{{- if .resources }}
+resources:
+  {{ toYaml .resources | nindent 2 }}
+{{- end }}
+{{- if .env }}
+env:
+{{ toYaml .env | nindent 2 }}
+{{- end }}
+{{- end }}
+{{- end -}}
+
+{{/* Generate init container properties */}}
+{{- define "initContainer.properties" -}}
+{{- with .Values.initContainer }}
+{{- if .enabled }}
+enabled: {{ .enabled }}
+image: {{ .image }}
+{{- if .imagePullPolicy }}
+imagePullPolicy: {{ .imagePullPolicy }}
+{{- end }}
+{{- if .resources }}
+resources:
+  {{ toYaml .resources | nindent 2 }}
+{{- end }}
+{{- if .env }}
+env:
+{{ toYaml .env | nindent 2 }}
+{{- end }}
+{{- if .command }}
+command:
+{{ toYaml .command | nindent 2 }}
+{{- end }}
+{{- if .args }}
+args:
+{{ toYaml .args | nindent 2 }}
+{{- end }}
+{{- end }}
+{{- end }}
+{{- end -}}
+

charts/redis-cluster/templates/extra-config.yaml

@@ -0,0 +1,17 @@
+{{- if eq .Values.externalConfig.enabled true }}
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: {{ .Values.redisCluster.name | default .Release.Name }}-ext-config
+  labels:
+    app.kubernetes.io/name: {{ .Values.redisCluster.name | default .Release.Name }}
+    helm.sh/chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    app.kubernetes.io/managed-by: {{ .Release.Service }}
+    app.kubernetes.io/instance: {{ .Values.redisCluster.name | default .Release.Name }}
+    app.kubernetes.io/version: {{ .Chart.AppVersion }}
+    app.kubernetes.io/component: middleware
+data:
+  redis-additional.conf: |
+    {{ .Values.externalConfig.data | nindent 4 }}
+{{- end }}

charts/redis-cluster/templates/follower-service.yaml

@@ -0,0 +1,29 @@
+{{- if and (gt (int .Values.redisCluster.follower.replicas) 0) (eq .Values.externalService.enabled true) }}
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: {{ .Values.redisCluster.name | default .Release.Name }}-follower-external-service
+{{- if .Values.externalService.annotations }}
+  annotations:
+{{ toYaml .Values.externalService.annotations | indent 4 }}
+{{- end }}
+  labels:
+    app.kubernetes.io/name: {{ .Values.redisCluster.name | default .Release.Name }}
+    helm.sh/chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    app.kubernetes.io/managed-by: {{ .Release.Service }}
+    app.kubernetes.io/instance: {{ .Values.redisCluster.name | default .Release.Name }}
+    app.kubernetes.io/version: {{ .Chart.AppVersion }}
+    app.kubernetes.io/component: middleware
+spec:
+  type: {{ .Values.externalService.serviceType }}
+  selector:
+    app: {{ .Values.redisCluster.name | default .Release.Name }}-follower
+    redis_setup_type: cluster
+    role: follower
+  ports:
+    - protocol: TCP
+      port: {{ .Values.externalService.port }}
+      targetPort: 6379
+      name: client
+{{- end }}

charts/redis-cluster/templates/follower-sm.yaml

@@ -0,0 +1,30 @@
+{{- if and (eq .Values.serviceMonitor.enabled true)  (gt (int .Values.redisCluster.follower.replicas) 0) }}
+---
+apiVersion: monitoring.coreos.com/v1
+kind: ServiceMonitor
+metadata:
+  name: {{ .Values.redisCluster.name | default .Release.Name }}-follower-prometheus-monitoring
+  labels:
+    app.kubernetes.io/name: {{ .Values.redisCluster.name | default .Release.Name }}
+    helm.sh/chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    app.kubernetes.io/managed-by: {{ .Release.Service }}
+    app.kubernetes.io/instance: {{ .Values.redisCluster.name | default .Release.Name }}
+    app.kubernetes.io/version: {{ .Chart.AppVersion }}
+    app.kubernetes.io/component: middleware
+    {{- with .Values.serviceMonitor.extraLabels }}
+    {{- toYaml . | nindent 4 }}
+    {{- end }}
+spec:
+  selector:
+    matchLabels:
+      app: {{ .Values.redisCluster.name | default .Release.Name }}-follower
+      redis_setup_type: cluster
+      role: follower
+  endpoints:
+  - port: redis-exporter
+    interval: {{ .Values.serviceMonitor.interval }}
+    scrapeTimeout: {{ .Values.serviceMonitor.scrapeTimeout }}
+  namespaceSelector:
+    matchNames:
+    - {{ .Values.serviceMonitor.namespace }}
+{{- end }}

charts/redis-cluster/templates/leader-service.yaml

@@ -0,0 +1,29 @@
+{{- if and (gt (int .Values.redisCluster.leader.replicas) 0) (eq .Values.externalService.enabled true) }}
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: {{ .Values.redisCluster.name | default .Release.Name }}-leader-external-service
+{{- if .Values.externalService.annotations }}
+  annotations:
+{{ toYaml .Values.externalService.annotations | indent 4 }}
+{{- end }}
+  labels:
+    app.kubernetes.io/name: {{ .Values.redisCluster.name | default .Release.Name }}
+    helm.sh/chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    app.kubernetes.io/managed-by: {{ .Release.Service }}
+    app.kubernetes.io/instance: {{ .Values.redisCluster.name | default .Release.Name }}
+    app.kubernetes.io/version: {{ .Chart.AppVersion }}
+    app.kubernetes.io/component: middleware
+spec:
+  type: {{ .Values.externalService.serviceType }}
+  selector:
+    app: {{ .Values.redisCluster.name | default .Release.Name }}-leader
+    redis_setup_type: cluster
+    role: leader
+  ports:
+    - protocol: TCP
+      port: {{ .Values.externalService.port }}
+      targetPort: 6379
+      name: client
+{{- end }}

charts/redis-cluster/templates/leader-sm.yaml

@@ -0,0 +1,30 @@
+{{- if and (eq .Values.serviceMonitor.enabled true) (gt (int .Values.redisCluster.leader.replicas) 0) }}
+---
+apiVersion: monitoring.coreos.com/v1
+kind: ServiceMonitor
+metadata:
+  name: {{ .Values.redisCluster.name | default .Release.Name }}-leader-prometheus-monitoring
+  labels:
+    app.kubernetes.io/name: {{ .Values.redisCluster.name | default .Release.Name }}
+    helm.sh/chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    app.kubernetes.io/managed-by: {{ .Release.Service }}
+    app.kubernetes.io/instance: {{ .Values.redisCluster.name | default .Release.Name }}
+    app.kubernetes.io/version: {{ .Chart.AppVersion }}
+    app.kubernetes.io/component: middleware
+    {{- with .Values.serviceMonitor.extraLabels }}
+    {{- toYaml . | nindent 4 }}
+    {{- end }}
+spec:
+  selector:
+    matchLabels:
+      app: {{ .Values.redisCluster.name | default .Release.Name }}-leader
+      redis_setup_type: cluster
+      role: leader
+  endpoints:
+  - port: redis-exporter
+    interval: {{ .Values.serviceMonitor.interval }}
+    scrapeTimeout: {{ .Values.serviceMonitor.scrapeTimeout }}
+  namespaceSelector:
+    matchNames:
+    - {{ .Values.serviceMonitor.namespace }}
+{{- end }}

charts/redis-cluster/templates/redis-cluster.yaml

@@ -0,0 +1,97 @@
+---
+apiVersion: redis.redis.opstreelabs.in/v1beta2
+kind: RedisCluster
+metadata:
+  name: {{ .Values.redisCluster.name | default .Release.Name }}
+  labels: {{- include "common.labels" . | nindent 4 }}
+  annotations:
+    {{ if .Values.redisCluster.recreateStatefulSetOnUpdateInvalid }}
+    redis.opstreelabs.in/recreate-statefulset: "true"
+    {{ end }}
+    {{- if .Values.redisCluster.enableMasterSlaveAntiAffinity }}
+    redisclusters.redis.redis.opstreelabs.in/role-anti-affinity: "true"
+    {{- end }}
+spec:
+  clusterSize: {{ .Values.redisCluster.clusterSize }}
+  persistenceEnabled: {{ .Values.redisCluster.persistenceEnabled }}
+  clusterVersion: {{ .Values.redisCluster.clusterVersion }}
+  redisLeader: {{- include "redis.role" .Values.redisCluster.leader | nindent 4 }}
+    replicas: {{ .Values.redisCluster.leader.replicas }}
+  {{- if .Values.externalConfig.enabled }}
+    redisConfig:
+      additionalRedisConfig: "{{ .Values.redisCluster.name | default .Release.Name }}-ext-config"
+  {{- end }}
+  
+  redisFollower: {{-  include "redis.role" .Values.redisCluster.follower | nindent 4 }}
+    replicas: {{ .Values.redisCluster.follower.replicas }}
+  {{- if .Values.externalConfig.enabled }}
+    redisConfig:
+      additionalRedisConfig: "{{ .Values.redisCluster.name | default .Release.Name }}-ext-config"
+  {{- end }}
+
+  redisExporter:
+    enabled: {{ .Values.redisExporter.enabled }}
+    image: "{{ .Values.redisExporter.image }}:{{ .Values.redisExporter.tag }}"
+    imagePullPolicy: "{{ .Values.redisExporter.imagePullPolicy }}"
+    {{- if .Values.redisExporter.resources}}
+    resources: {{ toYaml .Values.redisExporter.resources | nindent 6 }}
+    {{- end }}
+    {{- if .Values.redisExporter.env }}
+    env: {{ toYaml .Values.redisExporter.env | nindent 6 }}
+    {{- end }}
+    {{- if .Values.redisExporter.securityContext}}
+    securityContext: {{ toYaml .Values.redisExporter.securityContext | nindent 6 }}
+    {{- end }}
+    
+  kubernetesConfig:
+    image: "{{ .Values.redisCluster.image }}:{{ .Values.redisCluster.tag }}"
+    imagePullPolicy: "{{ .Values.redisCluster.imagePullPolicy }}"
+    {{- if .Values.redisCluster.imagePullSecrets}}
+    imagePullSecrets: {{ toYaml .Values.redisCluster.imagePullSecrets | nindent 4 }}
+    {{- end }}
+    {{- if .Values.redisCluster.resources}}
+    resources: {{ toYaml .Values.redisCluster.resources | nindent 6 }}
+    {{- end }}
+    {{- if and .Values.redisCluster.redisSecret.secretName .Values.redisCluster.redisSecret.secretKey }}
+    redisSecret:
+      name: {{ .Values.redisCluster.redisSecret.secretName | quote }}
+      key: {{ .Values.redisCluster.redisSecret.secretKey | quote }}
+    {{- end }}
+    {{- if .Values.redisCluster.minReadySeconds }}
+    minReadySeconds: {{ .Values.redisCluster.minReadySeconds}}
+    {{- end }}
+
+  {{- if .Values.storageSpec }}
+  storage: {{ toYaml .Values.storageSpec | nindent 4 }}
+  {{- end }}
+  {{- if and .Values.priorityClassName (ne .Values.priorityClassName "") }}
+  priorityClassName: "{{ .Values.priorityClassName }}"
+  {{- end }}
+  {{- if .Values.podSecurityContext }}
+  podSecurityContext: {{ toYaml .Values.podSecurityContext | nindent 4 }}
+  {{- end }}
+  {{- if and .Values.TLS.ca .Values.TLS.cert .Values.TLS.key .Values.TLS.secret.secretName }}
+  TLS:
+    ca: {{ .Values.TLS.ca | quote }}
+    cert: {{ .Values.TLS.cert | quote }}
+    key: {{ .Values.TLS.key | quote }}
+    secret:
+      secretName: {{ .Values.TLS.secret.secretName | quote }}
+  {{- end }}
+  {{- if and .Values.acl.secret (ne .Values.acl.secret.secretName "") }}
+  acl:
+    secret:
+      secretName: {{ .Values.acl.secret.secretName | quote }}
+  {{- end }}
+  {{- if and .Values.sidecars (ne .Values.sidecars.name "") (ne .Values.sidecars.image "") }}
+  sidecars: {{ include "sidecar.properties" . | nindent 4 }}
+  {{- end }}
+  {{- if and .Values.initContainer .Values.initContainer.enabled (ne .Values.initContainer.image "") }}
+  initContainer: {{ include "initContainer.properties" . | nindent 4 }}
+  {{- end }}
+  {{- if .Values.env }}
+  env: {{ toYaml .Values.env | nindent 4 }}
+  {{- end }}
+  {{- if and .Values.serviceAccountName (ne .Values.serviceAccountName "") }}
+  serviceAccountName: "{{ .Values.serviceAccountName }}"
+  {{- end }}

charts/redis-cluster/values.yaml

@@ -0,0 +1,224 @@
+---
+redisCluster:
+  name: ""
+  # -- Default number of replicas for both leader and follower when not explicitly set
+  clusterSize: 3
+  clusterVersion: v7
+  persistenceEnabled: true
+  image: quay.io/opstree/redis
+  tag: v7.0.15
+  imagePullPolicy: IfNotPresent
+  imagePullSecrets: {}
+    # - name:  Secret with Registry credentials
+  redisSecret:
+    secretName: ""
+    secretKey: ""
+  resources: {}
+    # requests:
+    #   cpu: 100m
+    #   memory: 128Mi
+    # limits:
+    #   cpu: 100m
+    #   memory: 128Mi
+  minReadySeconds: 0
+  # -- Some fields of statefulset are immutable, such as volumeClaimTemplates.
+  # When set to true, the operator will delete the statefulset and recreate it. Default is false.
+  recreateStatefulSetOnUpdateInvalid: false
+  # -- Enable pod anti-affinity between leader and follower pods by adding the appropriate label.
+  # Notice that this requires the operator to have its mutating webhook enabled,
+  # otherwise it will only add an annotation to the RedisCluster CR. Default is false.
+  enableMasterSlaveAntiAffinity: false
+  leader:
+    # -- Number of Redis leader (master) nodes. If not set, uses clusterSize value
+    replicas: 3
+    serviceType: ClusterIP
+    affinity: {}
+      # nodeAffinity:
+      #   requiredDuringSchedulingIgnoredDuringExecution:
+      #     nodeSelectorTerms:
+      #     - matchExpressions:
+      #       - key: disktype
+      #         operator: In
+      #         values:
+      #         - ssd
+    tolerations: []
+      # - key: "key"
+      #   operator: "Equal"
+      #   value: "value"
+      #   effect: "NoSchedule"
+    nodeSelector: null
+      # memory: medium
+    securityContext: {}
+    pdb:
+      enabled: false
+      maxUnavailable: 1
+      minAvailable: 1
+    livenessProbe: {}
+      # timeoutSeconds: 30
+      # periodSeconds: 45
+      # successThreshold: 1
+      # failureThreshold: 4
+      # initialDelaySeconds: 15
+    readinessProbe: {}
+      # timeoutSeconds: 30
+      # periodSeconds: 45
+      # successThreshold: 1
+      # failureThreshold: 4
+      # initialDelaySeconds: 15
+    
+  follower:
+    # -- Number of Redis follower (slave) nodes. If not set, uses clusterSize value
+    replicas: 3
+    serviceType: ClusterIP
+    affinity: null
+      # nodeAffinity:
+      #   requiredDuringSchedulingIgnoredDuringExecution:
+      #     nodeSelectorTerms:
+      #     - matchExpressions:
+      #       - key: disktype
+      #         operator: In
+      #         values:
+      #         - ssd
+    tolerations: []
+      # - key: "key"
+      #   operator: "Equal"
+      #   value: "value"
+      #   effect: "NoSchedule"
+    nodeSelector: null
+      # memory: medium
+    securityContext: {}
+    pdb:
+      enabled: false
+      maxUnavailable: 1
+      minAvailable: 1
+    livenessProbe: {}
+      # timeoutSeconds: 30
+      # periodSeconds: 45
+      # successThreshold: 1
+      # failureThreshold: 4
+      # initialDelaySeconds: 15
+    readinessProbe: {}
+      # timeoutSeconds: 30
+      # periodSeconds: 45
+      # successThreshold: 1
+      # failureThreshold: 4
+      # initialDelaySeconds: 15
+
+labels: {}
+#   foo: bar
+#   test: echo
+
+
+externalConfig:
+  enabled: false
+  data: |
+    tcp-keepalive 400
+    slowlog-max-len 158
+    stream-node-max-bytes 2048
+
+externalService:
+  enabled: false
+  # annotations:
+  #   foo: bar
+  serviceType: LoadBalancer
+  port: 6379
+
+serviceMonitor:
+  enabled: false
+  interval: 30s
+  scrapeTimeout: 10s
+  namespace: monitoring
+  # -- extraLabels are added to the servicemonitor when enabled set to true
+  extraLabels: {}
+    # foo: bar
+    # team: devops
+
+redisExporter:
+  enabled: false
+  image: quay.io/opstree/redis-exporter
+  tag: "v1.44.0"
+  imagePullPolicy: IfNotPresent
+  resources: {}
+    # requests:
+    #   cpu: 100m
+    #   memory: 128Mi
+    # limits:
+    #   cpu: 100m
+    #   memory: 128Mi
+  env: []
+    # - name: VAR_NAME
+    #   value: "value1"
+  securityContext: {}
+
+sidecars:
+  name: ""
+  image: ""
+  imagePullPolicy: "IfNotPresent"
+  resources:
+    limits:
+      cpu: "100m"
+      memory: "128Mi"
+    requests:
+      cpu: "50m"
+      memory: "64Mi"
+  env: {}
+    # - name: MY_ENV_VAR
+    #   value: "my-env-var-value"
+
+initContainer:
+  enabled: false
+  image: ""
+  imagePullPolicy: "IfNotPresent"
+  resources: {}
+    # requests:
+    #   memory: "64Mi"
+    #   cpu: "250m"
+    # limits:
+    #   memory: "128Mi"
+    #   cpu: "500m"
+  env: []
+  command: []
+  args: []
+
+priorityClassName: ""
+
+storageSpec:
+  volumeClaimTemplate:
+    spec:
+      # storageClassName: standard
+      accessModes: ["ReadWriteOnce"]
+      resources:
+        requests:
+          storage: 1Gi
+  nodeConfVolume: true
+  nodeConfVolumeClaimTemplate:
+    spec:
+      accessModes: ["ReadWriteOnce"]
+      resources:
+        requests:
+          storage: 1Gi
+  #   selector: {}
+
+podSecurityContext:
+  runAsUser: 1000
+  fsGroup: 1000
+
+
+# serviceAccountName: redis-sa
+
+TLS:
+  ca: ca.key
+  cert: tls.crt
+  key: tls.key
+  secret:
+    secretName: ""
+
+acl:
+  secret:
+    secretName: ""
+
+env: []
+  # - name: VAR_NAME
+  #   value: "value1"
+
+serviceAccountName: ""

charts/redis-operator/.gitignore

@@ -0,0 +1 @@
+*.tgz

charts/redis-operator/Chart.yaml

@@ -0,0 +1,22 @@
+---
+apiVersion: v2
+version: 0.21.2
+appVersion: "0.21.0"
+description: Provides easy redis setup definitions for Kubernetes services, and deployment.
+engine: gotpl
+maintainers:
+  - name: iamabhishek-dubey
+  
+  - name: sandy724
+  - name: shubham-cmyk
+name: redis-operator
+sources:
+  - https://github.com/OT-CONTAINER-KIT/redis-operator
+home: https://github.com/OT-CONTAINER-KIT/redis-operator
+icon: https://github.com/OT-CONTAINER-KIT/redis-operator/raw/main/static/redis-operator-logo.svg
+keywords:
+- operator
+- redis
+- opstree
+- kubernetes
+- openshift

charts/redis-operator/README.md

@@ -0,0 +1,138 @@
+# redis
+
+This Helm chart deploys the redis-operator into your Kubernetes cluster. The operator facilitates the deployment, scaling, and management of Redis clusters and other Redis resources provided by the OpsTree Solutions team.
+
+**Homepage:** <https://github.com/ot-container-kit/redis-operator>
+
+## Maintainers
+
+| Name | Email | Url |
+| ---- | ------ | --- |
+| iamabhishek-dubey |  |  |
+| sandy724 |  |  |
+| shubham-cmyk |  |  |
+
+## Pre-Requisities
+
+- Helm v3+
+- Kubernetes v1.16+
+- If you plan to use cert-manager integration (certmanager.enabled=true), cert-manager must be pre-installed in your cluster
+
+## Source Code
+
+* <https://github.com/ot-container-kit/redis-operator>
+
+## Installation Steps
+
+### 1. Add Helm Repository
+
+```bash
+helm repo add ot-helm https://ot-container-kit.github.io/helm-charts
+```
+
+### 2. Install Cert-Manager (Optional)
+
+If you plan to use cert-manager with the redis-operator, you need to install cert-manager before deploying the operator.
+You can follow the [official cert-manager installation guide](https://cert-manager.io/docs/installation/).
+
+### 3. Install Redis Operator
+
+Replace `<YourCertSecretName>` and `<YourPrivateKey>` with your specific values.
+
+```bash
+helm install <redis-operator> ot-helm/redis-operator --version=0.15.5 --appVersion=0.15.1 --set certificate.secretName=<YourCertSecretName> --set certmanager.enabled=true --set redisOperator.webhook=true --namespace <redis-operator> --create-namespace
+```
+
+> Note: If `certificate.secretName` is not provided, the operator will generate a self-signed certificate and use it for webhook server.
+---
+> Note : If you want to disable the webhook you have to pass the `--set webhook=false` and `--set certmanager.enabled=false`  while installing the redis-operator.
+---
+> Note: If you want to use an existing `ClusterIssuer` to sign the webhook certificate, you can pass `--set issuer.create=false`, `--set issuer.kind=ClusterIssuer` and `--set issuer.name=cluster-issuer-name-here` while installing the operator.
+
+### 4. Patch the CA Bundle (if using cert-manager)
+
+Cert-manager injects the CA bundle into the webhook configuration.
+
+```bash
+kubectl patch crd redis.redis.redis.opstreelabs.in -p '{"metadata":{"annotations":{"cert-manager.io/inject-ca-from":"<redis-operator>/<serving-cert>"}}}'
+
+kubectl patch crd redisclusters.redis.redis.opstreelabs.in -p '{"metadata":{"annotations":{"cert-manager.io/inject-ca-from":"<redis-operator>/<serving-cert>"}}}'
+
+kubectl patch crd redisreplications.redis.redis.opstreelabs.in -p '{"metadata":{"annotations":{"cert-manager.io/inject-ca-from":"<redis-operator>/<serving-cert>"}}}'
+
+kubectl patch crd redissentinels.redis.redis.opstreelabs.in -p '{"metadata":{"annotations":{"cert-manager.io/inject-ca-from":"<redis-operator>/<serving-cert>"}}}'
+```
+
+> Note: Replace `<redis-operator>` and `<serving-cert>` with your specific values i.e. release name and certificate name.
+
+#### You can verify the patch by running the following commands
+
+```bash
+kubectl get crd redis.redis.redis.opstreelabs.in -o=jsonpath='{.metadata.annotations}'
+kubectl get crd redisclusters.redis.redis.opstreelabs.in -o=jsonpath='{.metadata.annotations}'
+kubectl get crd redisreplications.redis.redis.opstreelabs.in -o=jsonpath='{.metadata.annotations}'
+kubectl get crd redissentinels.redis.redis.opstreelabs.in -o=jsonpath='{.metadata.annotations}'
+```
+
+### How to generate private key( Optional )
+
+```bash
+openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout tls.key -out tls.crt
+kubectl create secret tls <webhook-server-cert> --key tls.key --cert tls.crt -n <redis-operator>
+```
+
+> Note: This secret will be used for webhook server certificate so generate it before installing the redis-operator.
+
+## Values
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| affinity | object | `{}` |  |
+| certificate.name | string | `"serving-cert"` |  |
+| certificate.secretName | string | `"webhook-server-cert"` |  |
+| certmanager.apiVersion | string | `"cert-manager.io/v1"` |  |
+| certmanager.enabled | bool | `false` |  |
+| featureGates.GenerateConfigInInitContainer | bool | `false` |  |
+| issuer.create | bool | `true` |  |
+| issuer.email | string | `"shubham.gupta@opstree.com"` |  |
+| issuer.kind | string | `"Issuer"` |  |
+| issuer.name | string | `"redis-operator-issuer"` |  |
+| issuer.privateKeySecretName | string | `"letsencrypt-prod"` |  |
+| issuer.server | string | `"https://acme-v02.api.letsencrypt.org/directory"` |  |
+| issuer.solver.enabled | bool | `true` |  |
+| issuer.solver.ingressClass | string | `"nginx"` |  |
+| issuer.type | string | `"selfSigned"` |  |
+| manager.config.kubeClientQPS | float | `0` | If value > 0, it will override the default value in the operator |
+| manager.config.kubeClientTimeout | string | `"60s"` |  |
+| nodeSelector | object | `{}` |  |
+| podSecurityContext | object | `{}` |  |
+| priorityClassName | string | `""` |  |
+| rbac.enabled | bool | `true` |  |
+| redisOperator.automountServiceAccountToken | bool | `true` |  |
+| redisOperator.env | list | `[]` |  |
+| redisOperator.extraArgs | list | `[]` |  |
+| redisOperator.imageName | string | `"ghcr.io/ot-container-kit/redis-operator/redis-operator"` |  |
+| redisOperator.imagePullPolicy | string | `"Always"` |  |
+| redisOperator.imagePullSecrets | list | `[]` |  |
+| redisOperator.imageTag | string | `""` |  |
+| redisOperator.metrics.bindAddress | string | `":8080"` |  |
+| redisOperator.metrics.enabled | bool | `true` |  |
+| redisOperator.name | string | `"redis-operator"` |  |
+| redisOperator.podAnnotations | object | `{}` |  |
+| redisOperator.podLabels | object | `{}` |  |
+| redisOperator.pprof.bindAddress | string | `":6060"` |  |
+| redisOperator.pprof.enabled | bool | `false` |  |
+| redisOperator.watchNamespace | string | `""` |  |
+| redisOperator.webhook | bool | `false` |  |
+| replicas | int | `1` |  |
+| resources.limits.cpu | string | `"500m"` |  |
+| resources.limits.memory | string | `"500Mi"` |  |
+| resources.requests.cpu | string | `"500m"` |  |
+| resources.requests.memory | string | `"500Mi"` |  |
+| securityContext | object | `{}` |  |
+| service.name | string | `"webhook-service"` |  |
+| service.namespace | string | `"redis-operator"` |  |
+| serviceAccount.automountServiceAccountToken | bool | `true` |  |
+| serviceAccountName | string | `"redis-operator"` |  |
+| tolerateAllTaints | bool | `false` |  |
+| tolerations | list | `[]` |  |

charts/redis-operator/README.md.gotmpl

@@ -0,0 +1,86 @@
+# redis
+
+This Helm chart deploys the redis-operator into your Kubernetes cluster. The operator facilitates the deployment, scaling, and management of Redis clusters and other Redis resources provided by the OpsTree Solutions team.
+
+**Homepage:** <https://github.com/ot-container-kit/redis-operator>
+
+## Maintainers
+
+| Name | Email | Url |
+| ---- | ------ | --- |
+| iamabhishek-dubey |  |  |
+| sandy724 |  |  |
+| shubham-cmyk |  |  |
+
+## Pre-Requisities
+
+- Helm v3+
+- Kubernetes v1.16+
+- If you plan to use cert-manager integration (certmanager.enabled=true), cert-manager must be pre-installed in your cluster
+
+## Source Code
+
+* <https://github.com/ot-container-kit/redis-operator>
+
+## Installation Steps
+
+### 1. Add Helm Repository
+
+```bash
+helm repo add ot-helm https://ot-container-kit.github.io/helm-charts
+```
+
+### 2. Install Cert-Manager (Optional)
+
+If you plan to use cert-manager with the redis-operator, you need to install cert-manager before deploying the operator.
+You can follow the [official cert-manager installation guide](https://cert-manager.io/docs/installation/).
+
+### 3. Install Redis Operator
+
+Replace `<YourCertSecretName>` and `<YourPrivateKey>` with your specific values.
+
+```bash
+helm install <redis-operator> ot-helm/redis-operator --version=0.15.5 --appVersion=0.15.1 --set certificate.secretName=<YourCertSecretName> --set certmanager.enabled=true --set redisOperator.webhook=true --namespace <redis-operator> --create-namespace
+```
+
+> Note: If `certificate.secretName` is not provided, the operator will generate a self-signed certificate and use it for webhook server.
+---
+> Note : If you want to disable the webhook you have to pass the `--set webhook=false` and `--set certmanager.enabled=false`  while installing the redis-operator.
+---
+> Note: If you want to use an existing `ClusterIssuer` to sign the webhook certificate, you can pass `--set issuer.create=false`, `--set issuer.kind=ClusterIssuer` and `--set issuer.name=cluster-issuer-name-here` while installing the operator.
+
+### 4. Patch the CA Bundle (if using cert-manager)
+
+Cert-manager injects the CA bundle into the webhook configuration.
+
+```bash
+kubectl patch crd redis.redis.redis.opstreelabs.in -p '{"metadata":{"annotations":{"cert-manager.io/inject-ca-from":"<redis-operator>/<serving-cert>"}}}'
+
+kubectl patch crd redisclusters.redis.redis.opstreelabs.in -p '{"metadata":{"annotations":{"cert-manager.io/inject-ca-from":"<redis-operator>/<serving-cert>"}}}'
+
+kubectl patch crd redisreplications.redis.redis.opstreelabs.in -p '{"metadata":{"annotations":{"cert-manager.io/inject-ca-from":"<redis-operator>/<serving-cert>"}}}'
+
+kubectl patch crd redissentinels.redis.redis.opstreelabs.in -p '{"metadata":{"annotations":{"cert-manager.io/inject-ca-from":"<redis-operator>/<serving-cert>"}}}'
+```
+
+> Note: Replace `<redis-operator>` and `<serving-cert>` with your specific values i.e. release name and certificate name.
+
+#### You can verify the patch by running the following commands
+
+```bash
+kubectl get crd redis.redis.redis.opstreelabs.in -o=jsonpath='{.metadata.annotations}'
+kubectl get crd redisclusters.redis.redis.opstreelabs.in -o=jsonpath='{.metadata.annotations}'
+kubectl get crd redisreplications.redis.redis.opstreelabs.in -o=jsonpath='{.metadata.annotations}'
+kubectl get crd redissentinels.redis.redis.opstreelabs.in -o=jsonpath='{.metadata.annotations}'
+```
+
+### How to generate private key( Optional )
+
+```bash
+openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout tls.key -out tls.crt
+kubectl create secret tls <webhook-server-cert> --key tls.key --cert tls.crt -n <redis-operator>
+```
+
+> Note: This secret will be used for webhook server certificate so generate it before installing the redis-operator.
+
+{{ template "chart.valuesSection" . }}

charts/redis-operator/templates/NOTES.txt

@@ -0,0 +1,10 @@
+{{- template "redis-operator.validateConfig" . -}}
+
+Thank you for installing {{ .Chart.Name }}.
+
+Your release is named {{ .Release.Name }}.
+
+To learn more about the release, try:
+
+  $ helm status {{ .Release.Name }}
+  $ helm get all {{ .Release.Name }} 

charts/redis-operator/templates/_helpers.tpl

@@ -0,0 +1,43 @@
+{{/* vim: set filetype=mustache: */}}
+
+{{/* Define issuer spec based on the type */}}
+{{- define "redis-operator.issuerSpec" -}}
+{{- if eq .Values.issuer.type "acme" }}
+acme:
+  email: {{ .Values.issuer.email }}
+  server: {{ .Values.issuer.server }}
+  privateKeySecretRef:
+    name: {{ .Values.issuer.privateKeySecretName }}
+  solvers:
+  - http01:
+      ingress:
+        class: {{ .Values.issuer.solver.ingressClass }}
+{{- else }}
+selfSigned: {}
+{{- end }}
+{{- end -}}
+
+{{/* Common labels */}}
+{{- define "redisOperator.labels" -}}
+app.kubernetes.io/name: {{ .Values.redisOperator.name }}
+helm.sh/chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+app.kubernetes.io/managed-by: {{ .Release.Service }}
+app.kubernetes.io/instance: {{ .Release.Name }}
+app.kubernetes.io/version: {{ .Chart.AppVersion }}
+app.kubernetes.io/component: operator
+app.kubernetes.io/part-of: {{ .Release.Name }}
+{{- end }}
+
+{{/* Selector labels */}}
+{{- define "redisOperator.selectorLabels" -}}
+name: {{ .Values.redisOperator.name }}
+{{- end }}
+
+{{/*
+Validate webhook and cert-manager configuration
+*/}}
+{{- define "redis-operator.validateConfig" -}}
+{{- if and (not .Values.redisOperator.webhook) .Values.certmanager.enabled -}}
+{{- fail "certmanager.enabled should not be true when webhook is disabled" -}}
+{{- end -}}
+{{- end -}}

charts/redis-operator/templates/cert-manager.yaml

@@ -0,0 +1,40 @@
+{{ if .Values.certmanager.enabled }}
+{{- if .Values.issuer.create }}
+apiVersion: cert-manager.io/v1
+kind: {{ .Values.issuer.kind }}
+metadata:
+  name: {{ .Values.issuer.name }}
+  labels:
+    app.kubernetes.io/name: {{ .Values.redisOperator.name }}
+    helm.sh/chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    app.kubernetes.io/managed-by: {{ .Release.Service }}
+    app.kubernetes.io/instance: {{ .Release.Name }}
+    app.kubernetes.io/version: {{ .Chart.AppVersion }}
+    app.kubernetes.io/component: issuer
+    app.kubernetes.io/part-of: {{ .Release.Name }}
+spec:
+  {{- include "redis-operator.issuerSpec" . | nindent 2 }}
+---
+{{- end }}
+apiVersion: cert-manager.io/v1
+kind: Certificate
+metadata:
+  name: {{ .Values.certificate.name }}
+  namespace: {{ .Release.Namespace }}
+  labels:
+    app.kubernetes.io/name: {{ .Values.redisOperator.name }}
+    helm.sh/chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    app.kubernetes.io/managed-by: {{ .Release.Service }}
+    app.kubernetes.io/instance: {{ .Release.Name }}
+    app.kubernetes.io/version: {{ .Chart.AppVersion }}
+    app.kubernetes.io/component: certificate
+    app.kubernetes.io/part-of: {{ .Release.Name }}
+spec:
+  dnsNames:
+    - {{ .Values.service.name }}.{{ .Values.service.namespace }}.svc
+    - {{ .Values.service.name }}.{{ .Values.service.namespace }}.svc.cluster.local
+  issuerRef:
+    kind: {{ .Values.issuer.kind }}
+    name: {{ .Values.issuer.name }}
+  secretName: {{ .Values.certificate.secretName }}
+{{ end }}

charts/redis-operator/templates/mutating-webhook-configuration.yaml

@@ -0,0 +1,34 @@
+{{ if .Values.redisOperator.webhook }}
+
+apiVersion: admissionregistration.k8s.io/v1
+kind: MutatingWebhookConfiguration
+metadata:
+  name: mutating-webhook-configuration
+  annotations:
+    cert-manager.io/inject-ca-from: {{ .Release.Namespace }}/serving-cert
+webhooks:
+- admissionReviewVersions:
+  - v1
+  clientConfig:
+    service:
+      name: webhook-service
+      namespace: {{ .Release.Namespace }}
+      path: /mutate-core-v1-pod
+  failurePolicy: Fail
+  name: ot-mutate-pod.opstree.com
+  rules:
+  - apiGroups:
+    - ""
+    apiVersions:
+    - v1
+    operations:
+    - CREATE
+    resources:
+    - pods
+  sideEffects: None
+  objectSelector:
+    matchExpressions:
+      - key: redis_setup_type
+        operator: Exists
+
+{{ end }}

charts/redis-operator/templates/operator-deployment.yaml

@@ -0,0 +1,131 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: {{ .Values.redisOperator.name }}
+  namespace: {{ .Release.Namespace }}
+  labels: {{- include "redisOperator.labels" . | nindent 4 }}
+spec:
+  replicas: {{ .Values.replicas }}
+  selector:
+    matchLabels: {{- include "redisOperator.selectorLabels" . | nindent 6 }}
+  template:
+    metadata:
+      annotations:
+        cert-manager.io/inject-ca-from: {{ .Release.Namespace }}/{{ .Values.certificate.name }}
+      {{- with .Values.redisOperator.podAnnotations }}
+      {{- toYaml . | nindent 8 }}
+      {{- end }}
+      labels: {{- include "redisOperator.selectorLabels" . | nindent 8 }}
+      {{- with .Values.redisOperator.podLabels }}
+      {{- toYaml . | nindent 8 }}
+      {{- end }}
+    spec:
+      automountServiceAccountToken: {{ .Values.redisOperator.automountServiceAccountToken }}
+      {{- if .Values.redisOperator.imagePullSecrets }}
+      imagePullSecrets:
+        {{- toYaml .Values.redisOperator.imagePullSecrets | nindent 8 }}
+      {{- end }}
+      securityContext:
+        {{- toYaml .Values.podSecurityContext | nindent 8 }}
+      containers:
+      - name: "{{ .Values.redisOperator.name }}"
+        securityContext:
+          {{- toYaml .Values.securityContext | nindent 10 }}
+        image: "{{ .Values.redisOperator.imageName }}:{{ .Values.redisOperator.imageTag | default (printf "v%s" .Chart.AppVersion) }}"
+        imagePullPolicy: {{ .Values.redisOperator.imagePullPolicy }}
+        livenessProbe:
+          httpGet:
+            path: /healthz
+            port: probe
+        readinessProbe:
+          httpGet:
+            path: /readyz
+            port: probe
+        command:
+        - /operator
+        - manager
+        args:
+        - --leader-elect
+        {{- if .Values.redisOperator.pprof.enabled }}
+        - --pprof-bind-address={{ .Values.redisOperator.pprof.bindAddress }}
+        {{- end }}
+        {{- if .Values.redisOperator.metrics.enabled }}
+        - --metrics-bind-address={{ .Values.redisOperator.metrics.bindAddress }}
+        {{- end }}
+        {{- if .Values.manager.config.kubeClientTimeout }}
+        - --kube-client-timeout={{ .Values.manager.config.kubeClientTimeout }}
+        {{- end }}
+        {{- if and .Values.manager.config.kubeClientQPS (gt (.Values.manager.config.kubeClientQPS | float64) 0.0) }}
+        - --kube-client-qps={{ .Values.manager.config.kubeClientQPS }}
+        {{- end }}
+        {{- range $arg := .Values.redisOperator.extraArgs }}
+        - {{ $arg }}
+        {{- end }}
+        ports:
+        - containerPort: 8081
+          name: probe
+          protocol: TCP
+      {{- if .Values.redisOperator.metrics.enabled }}
+        - containerPort: {{ .Values.redisOperator.metrics.bindAddress | regexFind ":[0-9]+" | trimPrefix ":" }}
+          name: metrics
+          protocol: TCP
+      {{- end }}
+      {{- if .Values.redisOperator.pprof.enabled }}
+        - containerPort: {{ .Values.redisOperator.pprof.bindAddress | regexFind ":[0-9]+" | trimPrefix ":" }}
+          name: pprof
+          protocol: TCP
+      {{- end }}
+      {{- if .Values.redisOperator.webhook }}
+        - containerPort: 9443
+          name: webhook-server
+          protocol: TCP
+        volumeMounts:
+        - mountPath: /tmp/k8s-webhook-server/serving-certs
+          name: cert
+          readOnly: true
+      {{- end }}
+        env:
+        - name: ENABLE_WEBHOOKS
+          value: {{ .Values.redisOperator.webhook | quote }}
+        {{- if .Values.redisOperator.watchNamespace }}
+        - name: WATCH_NAMESPACE
+          value: {{ .Values.redisOperator.watchNamespace | quote }}
+        {{- end }}
+        {{- range $env := .Values.redisOperator.env }}
+        - name: {{ $env.name }}
+          value: {{ $env.value | quote }}
+        {{- end }}
+        {{- if .Values.featureGates }}
+        - name: FEATURE_GATES
+          value: "{{- $first := true -}}
+          {{- range $feature, $enabled := .Values.featureGates -}}
+          {{- if not $first -}},{{- end -}}
+          {{- $first = false -}}
+          {{- $feature }}={{ $enabled -}}
+          {{- end -}}"
+        {{- end }}
+      {{- if .Values.resources }}
+        resources: {{ toYaml .Values.resources | nindent 10 }}
+      {{- end }}
+      {{- with .Values.nodeSelector }}
+      nodeSelector: {{ toYaml . | nindent 8 }}
+      {{- end }}
+      {{- if .Values.priorityClassName}}
+      priorityClassName: {{ .Values.priorityClassName }}
+      {{- end }}
+      {{- with .Values.affinity }}
+      affinity: {{ toYaml . | nindent 8 }}
+      {{- end }}
+      {{- with .Values.tolerations }}
+      tolerations: {{ toYaml . | nindent 8 }}
+      {{- end }}
+      serviceAccountName: "{{ .Values.serviceAccountName }}"
+      serviceAccount: "{{ .Values.serviceAccountName }}"
+      {{- if .Values.redisOperator.webhook }}
+      volumes:
+      - name: cert
+        secret:
+          defaultMode: 420
+          secretName: {{ .Values.certificate.secretName }}
+      {{- end }}

charts/redis-operator/templates/role-binding.yaml

@@ -0,0 +1,23 @@
+{{- if .Values.rbac.enabled }}
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: {{ .Values.redisOperator.name }}
+  labels:
+    app.kubernetes.io/name : {{ .Values.redisOperator.name }}
+    helm.sh/chart : {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    app.kubernetes.io/managed-by : {{ .Release.Service }}
+    app.kubernetes.io/instance : {{ .Release.Name }}
+    app.kubernetes.io/version : {{ .Chart.AppVersion }}
+    app.kubernetes.io/component: role-binding
+    app.kubernetes.io/part-of : {{ .Release.Name }}
+subjects:
+- kind: ServiceAccount
+  name: {{ .Values.serviceAccountName }}
+  namespace: {{ .Release.Namespace }}
+roleRef:
+  kind: ClusterRole
+  name: {{ .Values.redisOperator.name }}
+  apiGroup: rbac.authorization.k8s.io
+{{- end }}

charts/redis-operator/templates/role.yaml

@@ -0,0 +1,128 @@
+{{- if .Values.rbac.enabled }}
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: {{ .Values.redisOperator.name }}
+  labels:
+    app.kubernetes.io/name : {{ .Values.redisOperator.name }}
+    helm.sh/chart : {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    app.kubernetes.io/managed-by : {{ .Release.Service }}
+    app.kubernetes.io/instance : {{ .Release.Name }}
+    app.kubernetes.io/version : {{ .Chart.AppVersion }}
+    app.kubernetes.io/component: role
+    app.kubernetes.io/part-of : {{ .Release.Name }}
+rules:
+- apiGroups:
+  - redis.redis.opstreelabs.in
+  resources:
+  - rediss
+  - redisclusters
+  - redisreplications
+  - redis
+  - rediscluster
+  - redissentinel
+  - redissentinels
+  - redisreplication
+  verbs:
+  - create
+  - delete
+  - get
+  - list
+  - patch
+  - update
+  - watch
+- nonResourceURLs:
+  - '*'
+  verbs:
+  - get
+- apiGroups: 
+  - "apiextensions.k8s.io"
+  resources: 
+  - "customresourcedefinitions"
+  verbs: 
+  - "get"
+  - "list" 
+  - "watch"
+- apiGroups:
+  - redis.redis.opstreelabs.in
+  resources:
+  - redis/finalizers
+  - rediscluster/finalizers
+  - redisclusters/finalizers
+  - redissentinel/finalizers
+  - redissentinels/finalizers
+  - redisreplication/finalizers
+  - redisreplications/finalizers
+  verbs:
+  - update
+- apiGroups:
+  - redis.redis.opstreelabs.in
+  resources:
+  - redis/status
+  - rediscluster/status
+  - redisclusters/status
+  - redissentinel/status
+  - redissentinels/status
+  - redisreplication/status
+  - redisreplications/status
+  verbs:
+  - get
+  - patch
+  - update
+- apiGroups:
+  - ""
+  resources:
+  - secrets
+  - pods/exec
+  - pods
+  - services
+  - configmaps
+  - events
+  - persistentvolumeclaims
+  - namespace
+  verbs:
+  - create
+  - delete
+  - get
+  - list
+  - patch
+  - update
+  - watch
+- apiGroups:
+  - apps
+  resources:
+  - statefulsets
+  verbs:
+  - create
+  - delete
+  - get
+  - list
+  - patch
+  - update
+  - watch
+- apiGroups:
+  - "coordination.k8s.io"
+  resources:
+  - leases
+  verbs:
+  - create
+  - delete
+  - get
+  - list
+  - patch
+  - update
+  - watch
+- apiGroups:
+    - "policy"
+  resources:
+  - poddisruptionbudgets
+  verbs:
+  - create
+  - delete
+  - get
+  - list
+  - patch
+  - update
+  - watch
+{{- end }}

charts/redis-operator/templates/service-account.yaml

@@ -0,0 +1,17 @@
+{{- if .Values.rbac.enabled }}
+---
+apiVersion: v1
+kind: ServiceAccount
+automountServiceAccountToken: {{ .Values.serviceAccount.automountServiceAccountToken }}
+metadata:
+  name: {{ .Values.redisOperator.name }}
+  namespace: {{ .Release.Namespace }}
+  labels:
+    app.kubernetes.io/name : {{ .Values.redisOperator.name }}
+    helm.sh/chart : {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    app.kubernetes.io/managed-by : {{ .Release.Service }}
+    app.kubernetes.io/instance : {{ .Release.Name }}
+    app.kubernetes.io/version : {{ .Chart.AppVersion }}
+    app.kubernetes.io/component: service-account
+    app.kubernetes.io/part-of : {{ .Release.Name }}
+{{- end }}

charts/redis-operator/templates/service.yaml

@@ -0,0 +1,22 @@
+{{ if .Values.redisOperator.webhook }}
+apiVersion: v1
+kind: Service
+metadata:
+  labels:
+    app.kubernetes.io/name : {{ .Values.redisOperator.name }}
+    helm.sh/chart : {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    app.kubernetes.io/managed-by : {{ .Release.Service }}
+    app.kubernetes.io/instance : {{ .Release.Name }}
+    app.kubernetes.io/version : {{ .Chart.AppVersion }}
+    app.kubernetes.io/component: webhook
+    app.kubernetes.io/part-of : {{ .Release.Name }}
+  name: {{ .Values.service.name }}
+  namespace:  {{ .Release.Namespace }}
+spec:
+  ports:
+    - port: 443
+      protocol: TCP
+      targetPort: 9443
+  selector:
+    name: {{ .Values.redisOperator.name }}
+{{ end }}