Working with remote repository

[termim]

Hello,
Is it possible to push/fetch patch series to/from remote repository?

[jpgrayson]

Good question.

The patches themselves are regular git commits and thus can be pushed.

But I think you're asking about not just the patches, but the stack state (metadata) that goes along with them too. That state is kept as objects in the repository, tracked by commits using the refs/stacks/<branch> ref. E.g. refs/stacks/main.

So, the stack state can also be pushed/fetched in a distributed fashion, but StGit does not provide tooling to do this in a smooth/turnkey manner. One basic problem that emerges right out of the gate is: how to ensure the patches are in sync with the stack state after pushing or pulling? I.e. because there are two refs (refs/heads/main and refs/stacks/main) that StGit keeps synchronized when running commands locally, but could easily get out of sync if StGit isn't managing both in tandem.

I've had interest in the past in workflows that involved keeping a series in sync between two machines using git primitives as the sync mechanism (as opposed to using something like rsync), but never developed tooling for it. If there were specific, valuable workflows identified, then we could consider adding tooling to StGit to help with those workflows.

[waynr]

Here's a workflow that I'd like:

• I start developing a feature on my home laptop for a tool that i also use on my work laptop
  • crucially, at this point i have a series of patches on the home laptop but each patch may still have changes coming as i make continued progress so it's important for me to preserve them
• I push my current feature branch to a git repo accessible to both laptops
• i pull that same feature branch on the work laptop
• i want to make changes to the feature while using it on my work laptop then later sync the changes back to my home laptop with the stacks/patches updated based on the latest development

so far i've tried updating my git config on both computers but it doesn't seem to do the trick:

[remote "waynr"]
	url = git@gitea.com:waynr/chooks
	fetch = +refs/heads/*:refs/remotes/waynr/*
	fetch = +refs/stacks/*:refs/stacks/waynr/*
	fetch = +refs/patches/*:refs/patches/waynr/*
	push = +refs/stacks/*:refs/stacks/waynr/*
	push = +refs/patches/*:refs/patches/waynr/*

I mean, I can push these refs to the shared remote from my home laptop then pull them from the shared remote to my work laptop but on the work laptop, stg doesn't seem to recognize them.

[jpgrayson]

Thanks for outlining this attempt. I think this is on the right track. How are you trying to ensure that your local refs/stacks/branch ref matches what you fetched from the remote? That seems to be where things are breaking down.

But note that after this wrinkle is ironed out, there will remain at least one big potential problem: There is no defined way to merge stack state. So if both environments modify stack state (which most stg commands do), the only recourse will be to pick one and reset both HEAD and refs/stacks/branch accordingly.

So "syncing" stack changes from two different machines is not a capability that is in reach. The only workable approach, IMO, is to do full hand-offs of the patch stack between your different machines, being disciplined about only working with the stack that has taken possession of the stack.

[lfrancke]

We'd love to maintain a bunch of "immutable" patches within our team.

I have one example where we maintain a bunch of "backports" to a base product and we'd like to be able to share this whole series between team members remotely.

We have a base product (HBase in this example) which we are building from source in a docker image but we do want to apply patches on top of that base version. We maintain these in the docker-images repo as patch files. And I maintain a fork of HBase where we have branches for each version we support. These branches were created using Stacked Git locally but other members from the team can't use them.

I understand that this is slightly different use-case and in this case the actual stack state doesn't matter and we'd be fine with always starting from all applied or none applied.

But I can't currently find a way to tell Stacked Git "everything after this commit is a patch". Is there such a command that I'm missing?

Also: Thank you very much for Stacked Git, it makes working with patches so much easier.