local-deploy.yml

# This workflow deploys docker images on a local kubernetes cluster.
name: Deploy K8s Locally

on:
    workflow_call:
        secrets:
            DATABASE_PASSWORD:
                required: true
            RABBITMQ_PASSWORD:
                required: true
            API_TOKEN_SECRET:
                required: true
            GPT_API_KEY:
                required: true
            TWELVEDATA_API_KEY_1:
                required: true
            TWELVEDATA_API_KEY_2:
                required: true
            FINNHUB_API_KEY:
                required: true
            STOCKSALOT_TLS_KEY:
                required: true
            STOCKSALOT_TLS_CERT:
                required: true
            GHCR_PAT:
                required: true
        inputs:
            DATABASE_USER:
                required: true
                type: string
            DATABASE_NAME:
                required: true
                type: string
            RABBITMQ_USER:
                required: true
                type: string
            API_TOKEN_EXPIRY_DAYS:
                required: true
                type: string
    workflow_dispatch:

jobs:
    build:
        uses: ./.github/workflows/build.yml

    test:
        env:
            DATABASE_USER: ${{ vars.DATABASE_USER || inputs.DATABASE_USER }}
            DATABASE_NAME: ${{ vars.DATABASE_NAME || inputs.DATABASE_NAME }}
            RABBITMQ_USER: ${{ vars.RABBITMQ_USER || inputs.RABBITMQ_USER }}
            API_TOKEN_EXPIRY_DAYS: ${{ vars.API_TOKEN_EXPIRY_DAYS || inputs.API_TOKEN_EXPIRY_DAYS }}
        needs: build
        runs-on: ubuntu-latest
        strategy:
            matrix:
                # kde: [kind, minikube]
                kde: [minikube]
            fail-fast: false
        steps:
            - uses: actions/checkout@v3

            - name: Create k8s Cluster (Kind)
              if: matrix.kde == 'kind'
              uses: helm/kind-action@v1.5.0
            - name: Create k8s Cluster (Minikube)
              if: matrix.kde == 'minikube'
              uses: medyagh/setup-minikube@master

            - name: Create Configmaps and Secrets
              run: |
                  kubectl create configmap db-config \
                      --from-literal=DATABASE_USER=${{ env.DATABASE_USER }} \
                      --from-literal=DATABASE_NAME=${{ env.DATABASE_NAME }}
                  kubectl create configmap db-server-config \
                      --from-literal=DATABASE_USER=${{ env.DATABASE_USER }} \
                      --from-literal=DATABASE_NAME=${{ env.DATABASE_NAME }} \
                      --from-literal=RABBITMQ_USER=${{ env.RABBITMQ_USER }} \
                      --from-literal=API_TOKEN_EXPIRY_DAYS=${{ env.API_TOKEN_EXPIRY_DAYS }}
                  kubectl create configmap ingestion-config \
                      --from-literal=RABBITMQ_USER=${{ env.RABBITMQ_USER }}
                  kubectl create configmap init-script-config \
                      --from-file=initdb.sh=./database/init/initdb.sh
                  kubectl create configmap rabbitmq-config \
                      --from-literal=RABBITMQ_DEFAULT_USER=${{ env.RABBITMQ_USER }}

                  kubectl create secret generic db-secrets \
                      --from-literal=POSTGRES_PASSWORD=${{ secrets.DATABASE_PASSWORD }}
                  kubectl create secret generic db-server-secrets \
                      --from-literal=DATABASE_PASSWORD=${{ secrets.DATABASE_PASSWORD }} \
                      --from-literal=RABBITMQ_PASSWORD=${{ secrets.RABBITMQ_PASSWORD }} \
                      --from-literal=API_TOKEN_SECRET=${{ secrets.API_TOKEN_SECRET }} \
                      --from-literal=GPT_API_KEY=${{ secrets.GPT_API_KEY }}
                  kubectl create secret generic ingestion-secrets \
                      --from-literal=RABBITMQ_PASSWORD=${{ secrets.RABBITMQ_PASSWORD }} \
                      --from-literal=TWELVEDATA_API_KEY_1=${{ secrets.TWELVEDATA_API_KEY_1 }} \
                      --from-literal=TWELVEDATA_API_KEY_2=${{ secrets.TWELVEDATA_API_KEY_2 }} \
                      --from-literal=FINNHUB_API_KEY=${{ secrets.FINNHUB_API_KEY }}
                  kubectl create secret generic rabbitmq-secrets \
                      --from-literal=RABBITMQ_DEFAULT_PASS=${{ secrets.RABBITMQ_PASSWORD }}

                  kubectl create secret docker-registry ghcr \
                      --docker-server=https://ghcr.io \
                      --docker-username=${{ github.actor }} \
                      --docker-password=${{ secrets.GHCR_PAT }} \
                      --docker-email=${{ github.event.pusher.email }}

                  echo "${{ secrets.STOCKSALOT_TLS_KEY }}" > stocksalot-tls.key
                  echo "${{ secrets.STOCKSALOT_TLS_CERT }}" > stocksalot-tls.crt
                  kubectl create secret tls stocksalot-tls \
                      --key=stocksalot-tls.key \
                      --cert=stocksalot-tls.crt

            - name: Apply Kubernetes Manifests
              run: |
                  kubectl apply -f k8s/database.yml
                  kubectl apply -f k8s/rabbitmq.yml
                  kubectl apply -f k8s/db-server.yml
                  kubectl apply -f k8s/ingestion.yml
                  kubectl apply -f k8s/db-server-service-account.yml

            - name: Start Cron Job Manually
              run: kubectl create job --from=cronjob/ingestion-cronjob-a ingestion-job

            - name: Check Running resources
              id: resource_check
              continue-on-error: true
              run: |
                  kubectl wait --for=condition=Ready pods --all --timeout=120s
                  kubectl get all

            - name: Examine resource_check result
              if: steps.resource_check.outcome == 'failure'
              run: |
                  kubectl get pods --field-selector status.phase!="Running" -o=jsonpath='{.items[*].metadata.name}' \
                  | xargs -n 1 kubectl describe pods
                  kubectl get pods --field-selector status.phase!="Running" -o=jsonpath='{.items[*].metadata.name}' \
                  | xargs -n 1 kubectl logs

            - name: Describe the Node
              if: steps.resource_check.outcome == 'failure'
              run: kubectl describe node

            - name: Fail if resource_check failed
              if: steps.resource_check.outcome == 'failure'
              continue-on-error: false
              run: exit 1

            - name: Sleep for 1 minute
              run: sleep 60

            - name: Check ingestion-job logs
              run: |
                  kubectl logs -l job-name=ingestion-job

            - name: Check db-server logs
              run: kubectl logs -l app=db-server