@znarf You can always set continue-on-error for the step and a failure will not cause the overall workflow to fail https://help.github.com/en/actions/automating-your-workflow-with-github-actions/workflow-syntax-for-github-actions#jobsjob_idstepscontinue-on-error.

For the second item we do have a feature on the backlog (no current timeframe) to have the outcome of a step be part of the steps context.

@chrispat Thank you for pointing on continue-on-error, I missed that. That could effectively replace the first item.

For the second item, I guess that should not be complicated to implement, I shared a proof of concept as Pull Request, let me know what you think.

@znarf the second item is not something that really should be implemented in a single action, it would need to be implemented in the runner so it is consistently applied to all actions. We do have a feature on our backlog to add steps.<step id>.outcome to the context.

@chrispat all right, let me know if there is an open issue so I can have a look.

@znarf unfortunately those issues are not in a public repo.

@chrispat Would the work be in https://github.com/actions/toolkit ? If yes, which of the packages https://github.com/actions/toolkit/tree/master/packages would be affected?

@znarf the work has to happen in the runner which is they only place where state is stored between executions of different actions.

this should be a small change. i'll open an ADR soon.

Thinking more about this, i believe you will get hit with a retry if you rely on failure.

A better solution might be to check if the branch exists (query REST API), and set an output that you can use in the if condition to determine whether to checkout from the other repo.

Something like this:

on: [push]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - id: check-branch
        uses: octokit/request-action@v2.x
        with:
          route: GET /repos/:owner/:repo/git/ref/:ref
          owner: some-owner
          repo: some-repo
          ref: heads/master
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        continue-on-error: true
      - if: steps.check-branch.outputs.status == 200
        run: echo Branch exists
      - if: steps.check-branch.outputs.status != 200
        run: echo Branch does not exist

However when 404, it appears octokit/request-action creates error annotations so i'm not sure thats what you want but it's close. Might be a good starting point.

also i noticed it doesnt appear to set any outputs when 404 (not even status)

I worked around this by testing for the existence of the branch using ‘git ls-remote’ then checking out the right branch. See:
NLnetLabs/krill@942f6a9

@ericsciple thank you for the elegant solution, I'll try that.

closing. fwiw proposal here for adding step outcome actions/runner#274

i"m having an issue with the steps check. If I have the following:

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Test failed
        id: failed
        run: exit 1
      - name: Test not failed
        id: notfailed
        if: success() || failure()
        run: exit 0
      - name: Should run
        id: bar
        if: steps.notfailed.outcome == 'success'
        run: exit 0

The Should run step is skipped, even thought steps.notfailed.outcome == 'success' evaluates to true. (did an echo of it and checked a dump to confirm)

But if I write the step as

      - name: Should run
        id: bar
        if: steps.notfailed.outcome == 'success' || success()
        run: exit 0

It works. It's like the step check is not enough? (Given that success() is false since the first step failed).

Any if block that does not contain a status function automatically has success() added with an &&. We do this because we believe in most cases customers only want steps to run if the overall job is successful.

Maybe the documentation can be improved? I didn't understand what you mentioned from reading it, but reading your message it's super clear.

You can use the following status check functions as expressions in if conditionals. If your if expression does not contain any of the status functions it will automatically result with success(). For more information about if conditionals, see "Workflow syntax for GitHub Actions."

Maybe replace

If your if expression does not contain any of the status functions it will automatically result with success()

With your message here

Any if block that does not contain a status function automatically has success() added with an &&.

After reading all of this and the other issue I'm still not sure what would be the "best ™️ " way to achieve this 😅

Maybe someone can chime in with a most optimized example?

My use case is to be able to do this private repos btw; I came up with this and it seems to work. The individual steps are "easy":

• get the "short" branch name from the long GITHUB_REf
• use octokit/request-action to fetch that branch from the other repo and remember the HTTP status code
  this needs continue-on-error: true
• small bash if condition to check on the status code and figure out if that branch is available or not
  write decision which branch to checkout into a new env var
• run action/checkout and use the env var from previous step

but it's quite a lot of boilerplate:

      - name: Extract branch name
        run: echo "::set-output name=branch::$(echo ${GITHUB_REF#refs/heads/})"
        id: extract-branch

      - name: Try to retrieve branch from otherrepo
        uses: octokit/request-action@v2.x
        id: get_branch_otherrepo
        with:
          route: GET /repos/user/otherrepo/branches/${{ steps.extract-branch.outputs.branch }}
        env:
          GITHUB_TOKEN: ${{ secrets.TOKEN_WITH_ACCESS_TO_OTHER_REPO }}
        continue-on-error: true

      - name: Determine which otherrepo branch to checkout
        run: |
          if [[ '${{ steps.get_branch_otherrepo.outputs.status }}' = '200' ]]; then
            OTHERREPO_BRANCH="${{ steps.extract-branch.outputs.branch }}"
          else
            OTHERREPO_BRANCH=master
          fi
          echo "Otherrepo branch for checkout: $OTHERREPO_BRANCH"
          echo "OTHERREPO_BRANCH=$OTHERREPO_BRANCH" >> $GITHUB_ENV

      - name: Checkout otherrepo
        uses: actions/checkout@v2
        with:
          repository: user/otherrepo
          token: ${{ secrets.TOKEN_WITH_ACCESS_TO_OTHER_REPO }}
          path: tmp/otherreppo
          ref:  ${{ env.OTHERREPO_BRANCH }}

Before I started out, I had a brute force approach in that I

• blindly ran action/checkout for otherrepo with the GITHUBREF of this repo
• if the checkout didn't work, run action/checkout for otherrepo on master

The downside was that action/checkout retries on errors and if the branch can't be found, it retries twice and we lose ~30 seconds or so.

The elaborate approach I came up with has "0 seconds latency" basically.

Thanks for any pointers/input!