config.yml

version: 2.1

executors:
  docker: # Docker using the Base Convenience Image
    parameters:
      resource_class:
        type: string
        default: "small"
    docker:
      - image: 'cimg/base:2025.02-20.04'
    resource_class: <<parameters.resource_class>>
  windows:  # Windows using the default windows image
    parameters:
      resource_class:
        type: string
        default: "medium"
    machine:
      image: windows-default
      shell: 'powershell.exe -ExecutionPolicy Bypass'
    resource_class: <<parameters.resource_class>>

commands:
  # resource_class verification commands to execute depending on executor_type
  verify_resource_class:
    parameters:
      resource_class:
        type: string
        default: "small"
      executor_type:
        type: string
        default: "docker"
    steps:
      - when:
          condition:
            equal: [ "docker", << parameters.executor_type >> ]
          steps:
            - run:
                name: verify required Environment Variables
                command: |
                  if [ -z "${CIRCLE_HOSTNAME}" -o -z "${CIRCLE_TOKEN}" ];then
                    echo "You must provide 2 Environment Variables in project settings for this job to run."
                    echo "CIRCLE_HOSTNAME: Should be the scheme://domain of your install. \"https://ci.example.com\""
                    echo "CIRCLE_TOKEN: Should be the API Key of an admin or project level with Scope:All"
                    exit 1
                  fi
            - run:
                name: Verify that job ran with the requested resource_class option
                command: |
                  curl -k \
                  "${CIRCLE_HOSTNAME%/}/api/v1.1/project/github/$CIRCLE_PROJECT_USERNAME/$CIRCLE_PROJECT_REPONAME/$CIRCLE_BUILD_NUM?\
                  circle-token=$CIRCLE_TOKEN" | \
                  jq '.picard.resource_class.class' | grep <<parameters.resource_class>>
      - when:
          condition:
            equal: [ "windows", << parameters.executor_type >> ]
          steps:
            - run:
                name: verify required Environment Variables
                command: |
                  if (!((Test-Path env:CIRCLE_HOSTNAME) -and (Test-Path env:CIRCLE_TOKEN))) {
                    Write-Host "You must provide 2 Environment Variables in project settings for this job to run."
                    Write-Host "CIRCLE_HOSTNAME: Should be the scheme://domain of your install. "https://ci.example.com""
                    Write-Host "CIRCLE_TOKEN: Should be the API Key of an admin or project level with Scope:All"
                    Exit 1
                  }
            - run:
                name: Verify that job ran with the requested resource_class option
                command: |
                  $job = Invoke-RestMethod -URI "$env:CIRCLE_HOSTNAME/api/v2/project/gh/$env:CIRCLE_PROJECT_USERNAME/$env:CIRCLE_PROJECT_REPONAME/job/$env:CIRCLE_BUILD_NUM" `
                    -Headers @{ "Circle-Token" = "$env:CIRCLE_TOKEN" }
                  $job.executor.resource_class | Select-String -Pattern "<<parameters.resource_class>>"

remote_docker_defaults: &remote_docker_defaults
  docker: [{image: 'docker:25.0-git'}]

basic_docker_build: &basic_docker_build
  name: "Build a really basic docker image"
  command: |
    dockerfile=Dockerfile
    echo "FROM alpine:latest" > $dockerfile
    echo "RUN echo hello" >> $dockerfile
    docker build -f $dockerfile --tag throwaway:$CIRCLE_BUILD_NUM .
    docker run --rm throwaway:$CIRCLE_BUILD_NUM

contexts_defaults: &contexts_defaults
  docker: [{image: 'alpine:latest'}]
  working_directory: /a/contexts/test

workspaces_defaults: &workspaces_defaults
  docker: [{image: 'circleci/node:latest'}]
  working_directory: ~/foo/bar

jobs:
  env-subst-example:
    executor: docker
    environment:
      foo: bar
      alpha: beta
    steps:
      - checkout
      - run:
          command: echo 'the value of foo is "$foo" and next to alpha is "$alpha"' > template.tmpl
      - run:
          command: cat template.tmpl
      - run:
          command: circleci env subst < template.tmpl > output.txt
      - run:
          command: grep "bar" output.txt | grep "beta"

  # job definition for verifying the resource_class per each executor_type
  executor_resource_class:
    parameters:
      resource_class:
        type: string
        default: "small"
      executor_type:
        type: string
        default: "docker"
    executor:
      name: <<parameters.executor_type>>
      resource_class: <<parameters.resource_class>>
    steps:
      - verify_resource_class:
          resource_class: <<parameters.resource_class>>
          executor_type: <<parameters.executor_type>>

  check_if_environment_is_aws:
    executor: docker
    steps:
      - run:
          name: Verify AWS Environment
          command: |
            if [ -z "${CIRCLE_CLOUD_PROVIDER}" ];then
              echo "You must provide the CIRCLE_CLOUD_PROVIDER environment variable in project settings for this job to run.";
              exit 1;
            fi
            if [[ "${CIRCLE_CLOUD_PROVIDER}" != 'aws' ]]; then
              echo "This installation is not in an AWS environment. Cancelling downstream workflow.";
              curl -X POST "${CIRCLE_HOSTNAME%/}/api/v2/workflow/$CIRCLE_WORKFLOW_ID/cancel?circle-token=$CIRCLE_TOKEN"
            fi

  check_if_environment_is_gcp:
    executor: docker
    steps:
      - run:
          name: Verify GCP Environment
          command: |
            if [ -z "${CIRCLE_CLOUD_PROVIDER}" ];then
              echo "You must provide the CIRCLE_CLOUD_PROVIDER environment variable in project settings for this job to run.";
              exit 1;
            fi
            if [[ "${CIRCLE_CLOUD_PROVIDER}" != 'gcp' ]]; then
              echo "This installation is not in an GCP environment. Cancelling downstream workflow.";
              curl -X POST "${CIRCLE_HOSTNAME%/}/api/v2/workflow/$CIRCLE_WORKFLOW_ID/cancel?circle-token=$CIRCLE_TOKEN"
            fi

  check_if_windows_is_enabled:
    executor: docker
    steps:
      - run:
          name: Verify if Windows enabled env flag is set to true
          command: |
            if [[ "${CIRCLE_WINDOWS_EXECUTOR}" != "true" ]]; then
              echo "Windows executor environment flag is not set to \"true\". Cancelling downstream workflow."
              curl -X POST "${CIRCLE_HOSTNAME%/}/api/v2/workflow/$CIRCLE_WORKFLOW_ID/cancel?circle-token=$CIRCLE_TOKEN"
            fi

  # vm jobs
  machine:
    machine: true
    steps:
      - run:
          <<: *basic_docker_build
      - run: |
          echo $SLEEP
          date
          sleep $SLEEP
          date
          echo 'Done sleeping.'
    environment:
      SLEEP: 1
  
  android_machine:
    machine:
      image: android-default
    steps:
      - run:
          <<: *basic_docker_build
      - run: |
          echo $SLEEP
          date
          sleep $SLEEP
          date
          echo 'Done sleeping.'
    environment:
      SLEEP: 1

  aws_arm:
    machine:
      image: arm-default
    resource_class: arm.medium
    steps:
      - run:
          <<: *basic_docker_build
      - run: |
          echo $SLEEP
          date
          sleep $SLEEP
          date
          echo 'Done sleeping.'
    environment:
      SLEEP: 1

  remote_docker:
    <<: *remote_docker_defaults
    steps:
      - run: which docker
      - run: docker -v
      - setup_remote_docker
      - run:
          <<: *basic_docker_build
      - run: docker version

  docker_layer_caching:
    <<: *remote_docker_defaults
    steps:
      - run: which docker
      - run: docker -v
      - setup_remote_docker:
          docker_layer_caching: true
      - run:
          <<: *basic_docker_build
      - run: docker version

  machine_dlc:
    machine:
      docker_layer_caching: true
    steps:
      - run: which docker
      - run: docker -v
      - run:
          <<: *basic_docker_build
      - run: docker version

  # feature jobs
  contexts:
    <<: *contexts_defaults
    steps:
      - run: env | grep CONTEXT_END_TO_END_TEST_VAR

  multi-contexts:
    <<: *contexts_defaults
    steps:
      - run: env | grep MULTI_CONTEXT_END_TO_END_VAR

  write_workspace:
    <<: *workspaces_defaults
    steps:
      - run: mkdir stuff
      - run: echo 5 >./stuff/thing
      - persist_to_workspace:
          root: .
          paths:
            - stuff

  read_workspace:
    <<: *workspaces_defaults
    steps:
      - attach_workspace:
           at: ./attached
      - run: |
          if [[ $(< ./attached/stuff/thing) != '5' ]]; then
            echo 'Sadness, the value is not what we expected, so the workspace write/read did not work'
            exit 1
          else
            echo 'Yay, value matches'
            exit 0
          fi

  save_and_restore_cache:
    docker:
      - image: circleci/python
    working_directory: ~/realitycheck
    steps:
      - checkout

      - run: mkdir -p stuff
      - run: echo 5 >./stuff/thing

      - save_cache:
          key: v3-file-cache-{{ .BuildNum }}
          paths:
            - ./stuff/thing

      - run: rm -rf ./stuff/thing
      - run: sleep 5

      - restore_cache:
            keys:
              - v3-file-cache-{{ .BuildNum }}

      - run: |
            if [[ $(< stuff/thing) != '5' ]]; then
              exit 1
            else
              echo "The cache was populated"
            fi

  artifacts_test_results:
    docker:
      - image: python:3.13.2
    working_directory: ~/realitycheck
    steps:
      - checkout

      - run:
          name: Creating Dummy Artifacts
          command: |
            echo "my artifact file" > /tmp/artifact-1.txt;
            mkdir /tmp/artifacts;
            echo "my artifact files in a dir" > /tmp/artifacts/artifact-2.txt;

      - store_artifacts:
          path: /tmp/artifact-1.txt
          destination: artifact-file.txt

      - store_artifacts:
          path: /tmp/artifacts

      - store_test_results:
          path: test-results

workflows:
  docker_resource_class_jobs:
    jobs:
      - executor_resource_class:
          matrix:
            parameters:
              resource_class: [small, medium, medium+, large, xlarge]
              executor_type: [docker] # default, but re-defining for clarity

  windows_resource_class_jobs:
    jobs:
      - check_if_windows_is_enabled
      - executor_resource_class:
          matrix:
            parameters:
              resource_class: [windows.medium, windows.large, windows.xlarge]
              executor_type: [windows]
          requires:
            - check_if_windows_is_enabled

  vm_jobs:
    jobs:
      - machine
      - remote_docker
      - docker_layer_caching
      - machine_dlc
  
  aws_jobs:
    jobs:
      - check_if_environment_is_aws
      - aws_arm:
          requires:
            - check_if_environment_is_aws
  
  gcp_jobs:
    jobs:
      - check_if_environment_is_gcp
      - android_machine:
          requires:
            - check_if_environment_is_gcp

  feature_jobs:
    jobs:
      - save_and_restore_cache
      - contexts:
          context: org-global
      - multi-contexts:
          context: individual-local
      - write_workspace
      - read_workspace:
          requires:
            - write_workspace
      - artifacts_test_results

  other_jobs:
    jobs:   
      - env-subst-example