Okay, I’ve tried lots of new things, and I figured something out. I can see the remote refs like this:

$ git ls-remote refs
[some hash number]        refs/heads/master
[some hash number]        refs/heads/test1

So the other branch does exist remotely. But still a branch list doesn’t show test1, so I can’t switch to it or fetch it.

$ git branch -a
* master
  remotes/origin/HEAD -> origin/master
  remotes/origin/master

This only occurs after using the checkout Action. When I clone with submodules locally everything is fine. I just don’t know if this is a bug for the checkout action or if I’m doing something wrong.

Hi @aormsby,

Submodules are not on a branch. They are just a pointer to a particular commit of the submodule’s repository.

After checkout the parent repo, you can update the submodule branch, and checkout the target branch then. Code sample as below(submodule : ticket7 with B1 branch)

      - name: checkout
        uses: actions/checkout@v2
        with:
          token: ${{ secrets.GITHUB_TOKEN }}    # you can use PAT token here.
      - name: update submodule branch
        run: |
           git config --file=.gitmodules submodule.Submod.branch B1  # change branch to 'B1' branch
           git submodule sync                        # sync
           git submodule update --init --recursive --remote   # pull the submodule
      - name: checkout submodule B1 branch
        run: |
          cd ticket7    # go to submodule repo
          git checkout -b B1 origin/B1   # checkout the target branch.

Please refer to my workflow for the details.

image1321×516 31.7 KB

Thanks

Ooooohhhhhh, this makes complete sense. I just didn’t realize I needed to set the branch property of .gitmodules to sync it that way. Nice solution.

There’s still one small snag for me. If the submodule is a private repo, I get a fatal error when I run the sync because the submodule URL doesn’t include user name and key information by default.

Cloning into '/home/runner/work/my/submod/path'...
fatal: could not read Username for 'https://github.com': No such device or address
fatal: clone of 'https://github.com/user/repo.git' into submodule path '/home/runner/work/my/submod/path' failed

I may be able to manipulate the URL in .gitmodules to include that, but I think it would be better to use the secret token like in the checkout. Shouldn’t the token credentials persist from the checkout action?? The readme says they should by default, but maybe I’m doing something wrong there as well.

Edit: Also, could you explain why keeping submodules: recursive in the workflow causes a fatal error? The update command results in fatal: Needed a single revision

@aormsby thank you so much! your back-and-forth (plus the detailed examples) saved me a whole bunch of time.

I wanted to add a couple of notes in case anyone else finds themselves here:

1. in @aormsby’s last comment, note that -C means that git is executing as if it was within the path that comes after it; i.e. commands are running from within the submodule without having to cd back and forth
2. the command git -C public checkout myBranch should (I think) have been written as git -C submodPath checkout myBranch

Here is an excerpt from my workflow, which checks out a submodule parent, updates the reference to a particular submodule, and pushes that out, in case anyone finds this helpful. My goal here is to have a workflow actually running from within the submodule / child repository that checks out its referencing parent and programmatically updates the reference its parent keeps to whatever the current branch is:

steps:
  - name: Checkout parent
    uses: actions/checkout@v2
    with:
      repository: owner/repo # these are fake -- must update
      token: ${{ secrets.GITHUB_TOKEN }}
      submodules: true # we in this case only want to update the specific submodule, not all
      path: parent

  - name: Update parent
    working-directory: parent
    run: | 
      echo "Updating parent"

      git config user.name git_user # fake, update
      git config user.email git_email # fake, update
      echo "git configuration complete"

      branch=$( echo ${{ github.ref }} | sed 's/refs\/heads\///g' )
      echo "working on parent branch ${branch}"
      if git rev-parse --quiet --verify $branch > /dev/null; then git checkout $branch; else git checkout -b $branch; fi;

      package=$(echo $GITHUB_REPOSITORY | sed 's:.*/::')
      echo "updating sudmodule for ${package}"

      git -C $package config remote.origin.fetch +refs/heads/*:refs/remotes/origin/*
      git submodule update --remote $package

      git -C $package checkout $branch
      echo "working on package branch ${branch}"

      git add .
      git commit -m "update reference to $package"
      git fetch
      git branch --set-upstream-to=origin/$branch
      
      git pull --no-edit
      git push

Turns out you can also do this:

# fetch the specific ref
git -C <submod-directory> fetch --depth=1 origin "refs/heads/<branch>"
do anything with it now!
git checkout <branch>

No idea what’s better/faster/stronger here, but this solution was definitely straightforward. Works for any ref you don’t already have access to from the initial checkout. :slight_smile:

Edit: I do want to be clear, though. Submodules are a pain, and different approaches work for different situations. For instance, my example here breaks my current work, and it’s annoying. Just something to be aware of.