FR: Resolve many SSH issues by having networked jj git commands shell out to git
#4979
Labels
Comments
arxanas
changed the title
jj git commands shell out to gitjj git commands shell out to git
|
It would certainly fix some issues. Do we have any concerns about inconsistency between git-backend ops performed by git itself and similar operations performed by jj's other commands? |
There are some existing issues, such as that some Git tooling doesn't handle commits with empty messages well. For that reason, |
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 2, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - it is using a new feature flag `shell` to switch on to shelling out. this doesn't seem the best approach, and it would be great to get some feedback on what would be best. A flag on jj git + adding it to the jj config seems to be a good enough idea Testing: Run the rust tests: ``` $ cargo test # checks we didn't screw up the baseline $ cargo test --features=shell # test the shelling out ``` Build with shell-out enabled: ``` $ cargo build --features=shell ``` Clone a private repo: ``` $ jj git clone <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push -b <branch> ```
4 tasks
|
As a potential risk, @emilazy pointed this out on Discord:
So we should be sure to think about the workflow+UX for Windows users, or anyone else who doesn't happen to have
|
|
Just to record what I said on the Discord, I think that it’s basically no issue for anything but Windows, and for a seamless Windows experience we could build our own Git binaries in CI and ship them with Jujutsu (in the limit, by using |
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 2, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 2, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 2, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 2, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 2, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 2, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 3, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 3, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 3, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 3, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 3, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 3, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 3, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 3, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 3, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 3, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
|
I think "for git interop, install git so that jj can use it to connect to remotes" is reasonable for now, even on Windows. We could make it a little better by trying some hardcoded locations in case of installs that haven't set PATH. |
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 3, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 4, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 4, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes shelling out to `git` for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] shell = true ``` Or via a CLI argument, e.g.: `jj git clone --shell <url>` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build with shell-out enabled: ``` $ cargo build ``` Clone a private repo: ``` $ jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ jj describe -m 'test commit' $ jj git push --shell -b <branch> ```
bsdinis
added a commit
to bsdinis/jj
that referenced
this issue
Jan 4, 2025
Reasoning: `jj` fails to push/fetch over ssh depending on the system. Issue jj-vcs#4979 lists over 20 related issues on this and proposes spawning a `git` subprocess for tasks related to the network (in fact, just push/fetch are enough). This PR implements this. Users can either enable shelling out to git in a config file: ```toml [git] subprocess = true ``` Implementation Details: This PR implements shelling out to `git` via `std::process::Command`. There are 2 sharp edges with the patch: - it relies on having to parse out git errors to match the error codes (and parsing git2's errors in one particular instance to match the error behaviour). This seems mostly unavoidable - to ensure matching behaviour with git2, the tests are maintained across the two implementations. This is done using test_case, as with the rest of the codebase Testing: Run the rust tests: ``` $ cargo test ``` Build: ``` $ cargo build ``` Clone a private repo: ``` $ path/to/jj git clone --shell <REPO_SSH_URL> ``` Create new commit and push ``` $ echo "TEST" > this_is_a_test_file.txt $ path/to/jj describe -m 'test commit' $ path/to/jj git push --shell -b <branch> ```
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Is your feature request related to a problem? Please describe.
Many
jj gitcommands fail on less common setups, oftentimes because libgit2 doesn't support certain features (see additional context).libgit2 itself uses libssh2 rather than OpenSSH, so it often doesn't behave the way that users would expect with their current
git/sshusage.We've discussed having
jj gitcommands literally shell out togit, rather than using the libgit2 implementation, most recently in #4937 (comment). I'm opening this issue to justify and track that proposal.Describe the solution you'd like
Change
jj gitcommands to executegitdirectly where appropriate.This is not risk-free. For example, git-branchless does this and instead has issues like
git sync --pull,git submithang indefinitely when asking for password (arxanas/git-branchless#433) (note that it tries to rungitin the background and communicate via stdin/stdout). But there are substantially fewer networking-related issues there, so it seems like a better default state of affairs for most users.Describe alternatives you've considered
gitat present for certain use-cases (reading certain config?).Additional context
Here's my enumeration of issues that might be resolved or resolveable by shelling out to Git. It would be nice if we could mostly solve them with a single mechanism!
SSH:
ssh://remote paths not supported. #2931jj git pushis not working for me on Windows #3322jjcan't set up new gitcredential.helperentries #4101jj git fetch .../jj git clone .../ etc. with a FIDO2 (resident) key #4591jj git pushto GitHub repository: can't authenticate on macOS #4870Clone/fetch/push/pull:
jj git push#1957jj git fetch --branch mainshould fetch tags #2295SSL error: unknown error#3851ssoorigin fail withError: invalid argument: 'port'; class=Invalid (3)#4177The text was updated successfully, but these errors were encountered: