action.yml

name: 'Kexa Action'
description: "It's Kexa version for a GitHub Action wrapped in Docker"
author: '4urcloud | Esteban MATHIA & Adrien EPPLING'
branding:
  icon: 'check-circle'
  color: 'blue'

inputs:
  ENV_VARS:
    description: 'All environment variables to be set in the .env file as a JSON object'
    required: true
    default: '{}'
  KUBECONFIG:
    description: 'Kubeconfig file content'
    required: false
    default: ''
  KUBEPREFIX:
    description: 'Kube var prefix'
    required: false
    default: ''
  WORKSPACECRED:
    description: 'Workspace credentials'
    required: false
    default: ''
  WORKSPACECRED_PREFIX:
    description: 'Workspace var prefix'
    required: false
    default: ''
  GOOGLE_APPLICATION_CREDENTIALS:
    description: 'Google application credentials'
    required: false
    default: ''
  GOOGLE_APPLICATION_CREDENTIALS_PREFIX:
    description: 'Google application credentials prefix'
    required: false
    default: ''
  JIRA_API_KEY:
    description: 'API key for Jira'
    required: false
    default: ''
  JIRA_DONE_STATUS:
    description: 'Done issue status for Jira project'
    required: false
    default: ''
  JIRA_PROJECT_KEY:
    description: 'Jira project key'
    required: false
    default: ''
  JIRA_DOMAIN:
    description: 'Jira domain used by user'
    required: false
    default: ''
  DB_CONNECTION_STRING:
    description: 'Database connection string'
    required: false
    default: ''
runs:
  using: 'composite'
  steps:
    - name: Checkout code
      uses: actions/checkout@v2

    ##################################
    #   ENVIRONMENT FILE CREATION    #
    ##################################

    - name: Create .env file with all environment variables
      run: echo '${{ inputs.ENV_VARS }}' > .env
      shell: bash

    # copy JIRA crendentials into env
    - name: Copy JIRA credentials into container
      run: |
        echo "JIRA_API_KEY=${{ inputs.JIRA_API_KEY }}" >> .env
        echo "JIRA_DONE_STATUS=${{ inputs.JIRA_DONE_STATUS }}" >> .env
        echo "JIRA_PROJECT_KEY=${{ inputs.JIRA_PROJECT_KEY }}" >> .env
        echo "JIRA_DOMAIN=${{ inputs.JIRA_DOMAIN }}" >> .env
      shell: bash

    # copy DB connection string into env
    - name: Copy DB connection string into container
      run: |
        echo "DB_CONNECTION_STRING=${{ inputs.DB_CONNECTION_STRING }}" >> .env
      shell: bash

    ##################################
    #   CONFIG FILE CREATION         #
    ##################################


    ###################
    #   KUBERNETES    #
    ###################

    - name: If Kubeconfig input exists, create kubeconfig file and set exist
      id: check_kubeconfig
      run: |
        if [ -n "${{ inputs.KUBECONFIG }}" ]; then
          echo "KUBECONFIG found."
          echo "${{ inputs.KUBECONFIG }}" > kubernetes.yaml
          echo "${{ inputs.KUBEPREFIX }}KUBECONFIG=/app/kubernetes.yaml" >> .env
          echo "${{ inputs.KUBECONFIG }} " > kubernetes.json

          chmod 700 kubernetes.json kubernetes.yaml
          echo "exists=true" >> $GITHUB_OUTPUT
        else
          echo "KUBECONFIG not found."
          echo "exists=false" >> $GITHUB_OUTPUT
        fi
      shell: bash

    - name: Multiple kubconfig, create files and set env variables
      id: check_kubeconfig_multiple
      if: steps.check_kubeconfig.outputs.exists == 'false'
      run: |
        if [ -z "${{ inputs.KUBEPREFIX }}" ]; then
          echo "KUBEPREFIX not found."
          exit 0
        fi

        KUBEPREFIXES="${{ inputs.KUBEPREFIX }}"
        IFS=',' read -r -a kubeprefixes <<< "$KUBEPREFIXES"

        if [ ${#kubeprefixes[@]} -gt 0 ]; then
          for idx in "${!kubeprefixes[@]}"; do
            prefix="${kubeprefixes[$idx]}"

            INPUT_PREFIX_KUBE="${prefix}KUBECONFIG"

            newInputs='${{ toJson(inputs) }}'
            kubeconfig=""
            for key in $(echo "$newInputs" | jq -r 'keys[]'); do
              value=$(echo "$newInputs" | jq -r ".\"$key\"")
              if [ "$key" == "$INPUT_PREFIX_KUBE" ]; then
                kubeconfig="${value}"
              fi
            done

            echo "${kubeconfig}" > "kubernetes_${idx}.yaml"
            echo "${prefix}KUBECONFIG=/app/kubernetes_${idx}.yaml" >> .env
            echo "${kubeconfig}" | python -c "import yaml, json, sys; yaml_content = sys.stdin.read(); print(json.dumps(yaml.safe_load(yaml_content), indent=2))" > kubernetes_${idx}.json
            chmod 700 "kubernetes_${idx}.yaml" "kubernetes_${idx}.json"
          done
          echo "exists=true" >> $GITHUB_OUTPUT
        else
          echo "No KUBEPREFIX values found."
          echo "exists=false" >> $GITHUB_OUTPUT
        fi
      shell: bash



    ###################
    #   WORKSPACE     #
    ###################


    - name: If Workspace credentials input exists, create workspace credentials file and set exist
      id: check_workspacecred
      run: |
            WORKSPACE_CREDS_COMPACT=$(echo '${{ inputs.WORKSPACECRED }}' | jq -c '.')
            if [ -n "$WORKSPACE_CREDS_COMPACT" ] && [ "$WORKSPACE_CREDS_COMPACT" != "null" ]; then
              echo "${{ inputs.WORKSPACECRED_PREFIX }}WORKSPACECRED=$WORKSPACE_CREDS_COMPACT" >> .env
              echo "exists=true" >> $GITHUB_OUTPUT
            else
              echo "exists=false" >> $GITHUB_OUTPUT
            fi
      shell: bash

    - name: Multiple workspace credentials, create files and set env variables
      if: steps.check_workspacecred.outputs.exists == 'false'
      run: |
        echo "checking for multiple workspace credentials"

        if [ -z "${{ inputs.WORKSPACECRED_PREFIX }}" ]; then
          echo "WORKSPACECRED_PREFIX not found."
          exit 0
        fi

        echo "WORKSPACECRED_PREFIX found for multiple conf."

        WORKSPACEPREFIXES="${{ inputs.WORKSPACECRED_PREFIX }}"
        IFS=',' read -r -a workspace_prefixes <<< "$WORKSPACEPREFIXES"

        if [ ${#workspace_prefixes[@]} -gt 0 ]; then
          for idx in "${!workspace_prefixes[@]}"; do
            prefix="${workspace_prefixes[$idx]}"

            INPUT_PREFIX_WORKSPACE="${prefix}WORKSPACECRED"

            newInputs='${{ toJson(inputs) }}'
            workspace=""
            for key in $(echo "$newInputs" | jq -r 'keys[]'); do
              value=$(echo "$newInputs" | jq -r ".\"$key\"")
              if [ "$key" == "$INPUT_PREFIX_WORKSPACE" ]; then
                workspace="${value}"
              fi
            done

            WORKSPACE_CREDS_COMPACT=$(echo "${workspace}" | jq -c '.')
            echo "${prefix}WORKSPACECRED=$WORKSPACE_CREDS_COMPACT" >> .env
          done
          echo "exists=true" >> $GITHUB_OUTPUT
        else
          echo "No WORKSPACECRED_PREFIX values found."
          echo "exists=false" >> $GITHUB_OUTPUT
        fi
      shell: bash

    

    ############
    #   GCP    #
    ############


    - name: If Google application credentials input exists, create Google application credentials file and set exist
      id: check_google_application_credentials
      run: |
            GCP_CREDS_COMPACT=$(echo '${{ inputs.GOOGLE_APPLICATION_CREDENTIALS }}' | jq -c '.')
            if [ -n "$GCP_CREDS_COMPACT" ] && [ "$GCP_CREDS_COMPACT" != "null" ]; then
              echo "${{ inputs.GOOGLE_APPLICATION_CREDENTIALS_PREFIX }}GOOGLE_APPLICATION_CREDENTIALS=$GCP_CREDS_COMPACT" >> .env
              echo "exists=true" >> $GITHUB_OUTPUT
            else
              echo "exists=false" >> $GITHUB_OUTPUT
            fi
      shell: bash

    - name: Multiple google application credentials, create files and set env variables
      if: steps.check_google_application_credentials.outputs.exists == 'false'
      run: |
        echo "checking for multiple GCP credentials"

        if [ -z "${{ inputs.GOOGLE_APPLICATION_CREDENTIALS_PREFIX }}" ]; then
          echo "GOOGLE_APPLICATION_CREDENTIALS_PREFIX not found."
          exit 0
        fi

        echo "GOOGLE_APPLICATION_CREDENTIALS_PREFIX found for multiple conf."

        GOOGLE_APPLICATION_CREDENTIALS_PREFIXES="${{ inputs.GOOGLE_APPLICATION_CREDENTIALS_PREFIX }}"
        IFS=',' read -r -a google_application_credentials_prefixes <<< "$GOOGLE_APPLICATION_CREDENTIALS_PREFIXES"

        if [ ${#google_application_credentials_prefixes[@]} -gt 0 ]; then
          for idx in "${!google_application_credentials_prefixes[@]}"; do
            prefix="${google_application_credentials_prefixes[$idx]}"

            INPUT_PREFIX_GCP="${prefix}GOOGLE_APPLICATION_CREDENTIALS"

            newInputs='${{ toJson(inputs) }}'
            gcp=""
            for key in $(echo "$newInputs" | jq -r 'keys[]'); do
              value=$(echo "$newInputs" | jq -r ".\"$key\"")
              if [ "$key" == "$INPUT_PREFIX_GCP" ]; then
                gcp="${value}"
              fi
            done

            GCP_CREDS_COMPACT=$(echo "$gcp" | jq -c '.')
            echo "${prefix}GOOGLE_APPLICATION_CREDENTIALS=$GCP_CREDS_COMPACT" >> .env
          done
          echo "exists=true" >> $GITHUB_OUTPUT
        else
          echo "No GOOGLE_APPLICATION_CREDENTIALS_PREFIX values found."
          echo "exists=false" >> $GITHUB_OUTPUT
        fi
      shell: bash

    ##################################
    #       RUN DOCKER IMAGE         #
    ##################################

    - name: Pull Docker image
      run: docker pull kexa/kexa:latest
      shell: bash

    - name: Stop and remove Docker container
      run: |
        containerId=$(docker ps -aqf name=^kexadockeractioncontainer$)
        echo "Container ID to delete: $containerId"
        if [ -n "$containerId" ]; then
          docker stop "$containerId"
          docker rm "$containerId"
        else
          echo "Container not found"
        fi
      if: always()
      continue-on-error: true
      shell: bash

    - name: Run Docker container
      run: |
        docker run -d -p 8000:8000 --name kexadockeractioncontainer --env-file .env kexa/kexa:latest sleep infinity
      shell: bash
      if: ${{ success() }}

    #############################################
    #       COPY CONFIGS INTO CONTAINER         #
    #############################################
 
    - name: Copy kubeconfig into container
      run: |
        docker cp kubernetes.yaml kexadockeractioncontainer:/app/
      shell: bash
      continue-on-error: true
      if: ${{ success() }}


    - name: Copy multiple kubeconfig into container
      run: |
        for file in kubernetes_*.yaml; do
          docker cp "$file" kexadockeractioncontainer:/app/
        done
      shell: bash
      continue-on-error: true
      if: ${{ success() }}

    - name: Copy multiple kubernetes json into container
      run: |
        for file in kubernetes_*.json; do
          docker cp "$file" kexadockeractioncontainer:/app/config/
        done
      shell: bash
      continue-on-error: true
      if: ${{ success() }}


    - name: Copy kube json into container
      run: |
        docker cp kubernetes.json kexadockeractioncontainer:/app/config/
      shell: bash
      continue-on-error: true
      if: ${{ success() }}

    - name: Copy rules into container
      run: |
        docker cp ./rules kexadockeractioncontainer:/app/
      shell: bash
      if: ${{ success() }}

    - name: Copy config into container
      run: |
        docker cp ./config kexadockeractioncontainer:/app/
      shell: bash
      if: ${{ success() }}

    #################################
    #       RUN KEXA SCRIPT         #
    #################################

    - name: Start main application inside container
      run: |
        docker exec kexadockeractioncontainer sh -c '
          cd /app
          bun run Kexa/main.ts
          EXIT_CODE=$?
          echo "Exit code: $EXIT_CODE"
          if [ $EXIT_CODE -ne 0 ]; then
            echo "bun run Kexa/main.ts failed with exit code $EXIT_CODE"
            exit $EXIT_CODE
          fi
        '
      shell: bash


    # delete kube config file if created
    - name: Delete kubeconfig file
      if: steps.check_kubeconfig.outputs.exists == 'true'
      run: rm kubernetes.yaml
      continue-on-error: true
      shell: bash

    # delete multiple kube config files if created
    - name: Delete multiple kubeconfig files
      if: steps.check_kubeconfig_multiple.outputs.exists == 'true'
      run: rm kubernetes_*.yaml kubernetes_*.json
      continue-on-error: true
      shell: bash



    - name: Delete .env file
      run: rm .env
      continue-on-error: true
      shell: bash

    - name: Stop and remove Docker container
      run: |
        containerId=$(docker ps -qf name=^kexadockeractioncontainer$)
        echo "Container ID to delete: $containerId"
        if [ -n "$containerId" ]; then
          docker stop "$containerId"
          docker rm "$containerId"
        else
          echo "Container not found"
        fi
      if: always()
      continue-on-error: true
      shell: bash