Changes to BMO-Phabricator integration
Mark Côté
To reduce confusion and a growing maintenance burden, the Engineering Workflow team plans to remove two pieces of Phabricator-Bugzilla integration:
The setting of r+ flags on the stub attachments in that link to Phabricator revisions (https://bugzilla.mozilla.org/show_bug.cgi?id=1490687).
The Phabricator table in Bugzilla’s “My Requests” page (https://bugzilla.mozilla.org/show_bug.cgi?id=1487422).
We plan on adding one more piece of integration: a panel on bug views (show_bug.cgi) that shows the status of Phabricator revisions in Phabricator’s terms, similar to the old MozReview table (https://bugzilla.mozilla.org/show_bug.cgi?id=1489706).
The “stub attachments” will remain for the time being in order to facilitate tracking non-review attachment flags (checkin-needed, etc).
# Rationale and background
There have been a lot of questions about our decisions surrounding Bugzilla–Phabricator integration. We’ve expounded on those in various threads over the last year and a half, but I will try to go into more specifics.
At the start of the Phabricator project, having learned a lot from MozReview, we consciously decided to limit the amount of integration to Bugzilla. This not only reduces upfront costs and maintenance burden but also avoids the complexity and ambiguity inherent in mixing two different systems together. Aside from necessary linkages like authentication, accounts, and security groups, the only other integration we implemented was the setting of r+ statuses on stub attachments and, later, adding Phabricator requests to BMO’s “My Dashboard”.
Unfortunately both of these have had bugs and caused confusion. Since comments aren’t mirrored, the plain r+s were sometimes misleading if the revisions (or Phabricator’s email notifications) weren’t also consulted before landing. The requests view on “My Dashboard” suffered from bugs that resulted in missing requests and was further impacted by our experiments with reviewer groups that have no real analog in Bugzilla.
# Differing models
The central problem is that the models behind the two systems—Bugzilla’s attachments and flags, Phabricator’s revisions and reviews—are very different. Phabricator’s revisions have a much richer and more complex set of metadata than Bugzilla attachments. It is essentially impossible to represent Phabricator states as Bugzilla flags while preserving anything close to the expected semantics of the latter; consulting Phabricator would often be needed to make sense of any translated representation in Bugzilla. Further, Phabricator’s model is also subject to changes and additions (for example, the draft revision state, which is still being modified), which creates additional fragility and maintenance burden. Finally, not all the details we need are even exposed through APIs, in part because they are in flux.
# Adding revision statuses to bugs
That said, we realize that seeing at a glance the state of revisions associated with a given bug is very useful. We are building support into Bugzilla to view revision data without translation into Bugzilla’s terms to avoid any confusion as to the true state of revisions.
While we could also dump data from Phabricator’s dashboard into Bugzilla’s “My Dashboard”, it would be much more work and more difficult to maintain, since Phabricator’s dashboard itself is being updated. Furthermore, as all code reviews are transitioned to Phabricator, the importance of this dashboard will grow, and the number of requests in Bugzilla will shrink. Thus relying on Phabricator to do what it does best is the better solution for the future.
# Acknowledging difficulties
We are aware that splitting code review out into a separate system is a huge change. We realize that, with our new tools and the decisions we have made around integration, we are asking you to change your workflows by setting up different email rules, looking in different places for the data you need, communicating with other Mozillians in different ways, and perhaps even establishing new practices and norms around code review. It will take time to adapt. However we are already seeing benefits in terms of automation that we haven’t previously been able to do (just one example: a user set up Herald rules to notify of changes that impact localization), and we will continue to build on this framework to accomplish goals that have been talked about for many years. Allowing the tools to do what they are best at lets us focus on new functionality, including suggested reviewers, Try support for Lando, Lando notifications, fully automated landings, and other items on our road map (https://wiki.mozilla.org/Engineering_Workflow/Road_Map).
We appreciate your feedback and support as we work to improve the tools you use every day.
Ehsan Akhgari
As someone who cares a lot about code review (both as a developer and as a reviewer), I care a lot about the tools I work with and the workflows I’ve built around them over the years. I’m sure I’m not the only one there.
What Mark wrote about below brings changes to some parts of our code review workflows and I think it’s fair to assume that some people will find the change unpleasant. I think it’s important to know that decisions like this aren’t made lightly though, and the team working on Phabricator has looked into making this integration work as much as possible, before coming to this final conclusion.
What I’ve learned from the experience of the folks who worked closely on this project over the past 3-4 years is that integrating an existing code review system with an existing issue management system is an extremely difficult task. There are certainly huge benefits to be reaped if a tight integration is achieved, but there are great costs to also consider, and the trade-off is tricky to get right.
As much as deep down in my heart, I secretly wish nothing would ever change so that I could hold on to my old habits until who-knows-when, I realize that sometimes it’s prudent to do what’s hard -- shaking off old habits and workflows and pick up new ones, in the interest of the greater good.
In this case, even with my reviewer hat on, I think it would certainly be a mistake for us to have tried as hard as we did for MozReview to integrate BMO and Phabricator together at the expense of holding back the deployment of Phabricator and new features in it. If our smart engineers working on this hard problem have looked at this integration issue, have tried to make it work, and have decided down the line that it’s best to correct course, my hunch is to trust them and consider maybe it’s time to change some of my old habits on how I interact with code reviews on Bugzilla.
Thanks,
Ehsan
_______________________________________________
firefox-dev mailing list
firef...@mozilla.org
https://mail.mozilla.org/listinfo/firefox-dev
--
James Graham
On 12/09/2018 15:37, Mark Côté wrote:
> To reduce confusion and a growing maintenance burden, the Engineering
> Workflow team plans to remove two pieces of Phabricator-Bugzilla
> integration:
>
>
> 1.
>
> The setting of r+ flags on the stub attachments in that link to
> Phabricator revisions
> (https://bugzilla.mozilla.org/show_bug.cgi?id=1490687).
>
> 2.
>
> The Phabricator table in Bugzilla’s “My Requests” page
> (https://bugzilla.mozilla.org/show_bug.cgi?id=1487422).
One of the things that has been nice about working with Mozilla tooling
is that Bugzilla provided a unified list of outstanding requests
(reviews, needinfos, etc.). Losing this is making it easier to
accidentially drop the ball on requests and so unintentionally block
other people's work. This is a common problem I face on systems like
GitHub that don't make it obvious what is pending.
Are there any plans for some system that would provide this unified view
across the bugtracker, review tools, etc.?
Mark Côté
One of the things that has been nice about working with Mozilla tooling is that Bugzilla provided a unified list of outstanding requests (reviews, needinfos, etc.). Losing this is making it easier to accidentially drop the ball on requests and so unintentionally block other people's work. This is a common problem I face on systems like GitHub that don't make it obvious what is pending.
Are there any plans for some system that would provide this unified view across the bugtracker, review tools, etc.?
Bobby Holley
Axel Hecht
Public service announcement, this is one of the best-hidden gems on github:
https://github.com/pulls/review-requested is your review-requested dashboard. You can get there from github.com by clicking on the "Pull requests" link in the header, and then "Review requests".
Axel
James Graham
> To boil this down a bit: GH reviews are easy to miss because there is no
> GH review dashboard. There is a dashboard in Phabricator, and the impact
> of this change is that you'll need to monitor two dashboard for the
> foreseeable future (Bugzilla and Phabricator). But it's just 2, not N,
> which is why it's a reasonable thing to ask for given the constraints
> Mark outlined.
because it's not visible/part of the normal workflow it's not that useful.
To be clear this is not a general objection to the change; I fully
understand that there are substantial issues keeping multiple systems in
sync, and I think that not trying to do so has end user benefits as well
as problems (e.g. by forcing all code review comments to go in the code
review system rather than splitting them across the code review and the
bug tracker, it's actually possible to track which comments are
addressed in a reasonable/tool-supported way, which seems like a pretty
basic thing one should be able to do with code review comments, and has
historically not been possible when working on Gecko). However the
single request queue has been a major highlight of the Mozilla
tooling/workflow, and it seems reasonable to at least ask if there's
some path back to that.
Andrew McCreight
On Wed, Sep 12, 2018 at 10:54 AM, James Graham <ja...@hoppipolla.co.uk> wrote:
One of the things that has been nice about working with Mozilla tooling is that Bugzilla provided a unified list of outstanding requests (reviews, needinfos, etc.). Losing this is making it easier to accidentially drop the ball on requests and so unintentionally block other people's work. This is a common problem I face on systems like GitHub that don't make it obvious what is pending.
Are there any plans for some system that would provide this unified view across the bugtracker, review tools, etc.?I tried to cover this in my post, but (a) it is surprisingly hard to get the current list of requests from Phabricator via their APIs. I believe mconley tried to make a webextension to do this and ran into many edge cases; he could tell you more. This is why I encouraged consulting the Phabricator dashboard directly. (b) For many devs, GH requests are one-offs and hence are easy to miss because they aren't part of a daily workflow. As more reviews move to Phabricator, this won't be an issue.
But if someone really wants to try combining them, perhaps a webextension for Phabricator that displays Bugzilla requests makes more sense than the other way around.Mark