Date
1 - 6 of 6
[edk2-devel] [edk2-rfc] GitHub Pull Request based Code Review Process
|
Rebecca Cran
Mike,
On 5/10/20 3:29 PM, Michael D Kinney wrote: There is no difference between CI checks run during code reviewI'd suggest following what other Github projects do, which I think is to run the CI checks automatically on every change that's made in a pull request - I don't know if it might also be necessary to run them during the merge, if master has changed in the meantime. That gives the _submitter_ feedback about any changes they need to make, instead of having to wait until the maintainer tells them their change has broken something: it speeds up the development process. Mergify is more flexible. We want to make sure the git historyWouldn't disabling all but "Allow rebase merging" do the same thing without the additional potential failure point? Though it sounds like we've resolved the problems with Mergify, so it's not important. https://help.github.com/en/github/administering-a-repository/configuring-commit-squashing-for-pull-requests -- Rebecca Cran |
|
|
|
Laszlo Ersek
On 05/11/20 03:37, Michael D Kinney wrote:
There was feedback from Laszlo related to rebase forTo clarify, I don't think we should allow any github-side automatism to auto-rebase pull requests. I think such rebases need to occur on personal developer machines, under human oversight, and then resubmitted (likely: force-pushed). My request is that the build costs (time, energy) associated with such force-pushes be reduced somehow. For example, on a local machine, the following sequence: $ git checkout master $ git pull $ git rebase -i master my_topic_branch $ build ... would trigger an incremental build. *.c files not touched by either operation would not have to be re-built (assuming their dependencies didn't change either, such as lib class headers, protocol headers, ...) Thanks, Laszlo |
|
|
|
Laszlo Ersek
On 05/10/20 23:43, Rebecca Cran wrote:
Mike,Build-testing at every stage through a patch series is important for ensuring bisectability. But there's a critical ingredient to that: based on the assumption that our build system / build rules are good, the builds mentioned above should be *incremental*. That is, if we have a patch set with 10 patches, then then the first patch in the series should trigger a complete build, and the 9 later patches should trigger only incremental builds. (During a bisection, the same commits wouldn't be visited in that same order of course, but that's where the sanity of the build system / build rules comes in! Basically, if your builds succeed with a linear progression through the series, then the build system / build rules ought to *guarantee* that the same "tree states" will build incrementally just fine when visited in any particular order. "git checkout" updates the relevant files, and the build system should be able to derive the minimum set of necessary actions. Anyway, digression ends.) The incremental nature of builds is important for saving energy, and also for saving developer time. The above 10-part example series should not take 10 times as long to build as 10 independent patches, submitted in isolation. Patches#2 through #10 should only rebuild a few modules each (unless lib class headers, protocol headers and such are modified). mergify has been pretty stable for me!Mergify is more flexible. We want to make sure the git historyWouldn't disabling all but "Allow rebase merging" do the same thing Thanks, Laszlo |
|
|
|
Laszlo Ersek
On 05/10/20 23:29, Michael D Kinney wrote:
Rebecca,( Wow, "squash-on-merge" is even the *default* now? That's terrible. Unfortunately, github.com sets a very bad example with this, which is made worse by github's popularity. How can we expect developers to think about bisectability and patch series structuring as first class traits of their contributions if github.com actively educates them to ignore those aspects? Shaking my head. ) Laszlo |
|
|
|
Michael D Kinney
Rebecca,
toggle quoted message
Show quoted text
I agree that the first version should rerun CI checks on every time commits are added to a PR or there is a forced push to the PR. Perhaps we should use Draft Pull Requests as a way to indicate the content is not ready for code review or CI checks yet. https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests#draft-pull-requests We also want emails added to the email archive when the pull request is either abandoned or merged. merify can add comments to a PR that are picked up by the webhook. I agree with reducing the number of services required. There was feedback from Laszlo related to rebase for pull requests using the current CI process. I will do more investigations of GitHub features, webhook features, and Mergify features to see if there is simpler overall solution. Mike -----Original Message----- |
|
|
|
Michael D Kinney
Rebecca,
toggle quoted message
Show quoted text
There is no difference between CI checks run during code review and the final CI checks before merge. I think it is an interesting conversation to decide how many times those CI checks should be run and if they should run automatically on every change during review or on demand. Mergify is more flexible. We want to make sure the git history is linear with not git merges and supports both single patches and patch series without squashing. GitHub merge button by default squashes all commits into a single commit. Thanks, Mike -----Original Message----- |
|
|