Magnum is made possible by a wide base of contributors from numerous countries and time zones around the world. We work as a team in accordance with the Guiding Principles of the OpenStack Community. We all want to be valued members of a successful team on an inspiring mission. Code contributions are merged into our code base through a democratic voting process. Anyone may vote on patches submitted by our contributors, and everyone is encouraged to make actionable and helpful suggestions for how patches can be improved prior to merging. We strive to strike a sensible balance between the speed of our work, and the quality of each contribution. This document describes the correct balance in accordance with the prevailing wishes of our team.
This document is an extension of the OpenStack Governance that explicitly converts our tribal knowledge into a codified record. If any conflict is discovered between the OpenStack governance, and this document, the OpenStack documents shall prevail.
Everyone in our community is expected to know and comply with the OpenStack Community Code of Conduct. We all need to work together to maintain a thriving team that enjoys working together to solve challenges.
When making contributions to any Magnum code repository, contributors shall expect their work to be peer reviewed. See Merge Criteria for details about how reviewed code is approved for merge.
Expect reviewers to vote against merging a patch, along with actionable suggestions for improvement prior to merging the code. Understand that such a vote is normal, and is essential to our quality process.
If you receive votes against your review submission, please revise your work in accordance with any requests, or leave comments indicating why you believe the work should be further considered without revision.
If you leave your review without further comments or revision for an extended period, you should mark your patch as Abandoned, or it may be marked as Abandoned by another team member as a courtesy to you. A patch with no revisions for multiple weeks should be abandoned, or changed to work in progress (WIP) with the workflow-1 flag. We want all code in the review queue to be actionable by reviewers. Note that an Abandoned status shall be considered temporary, and that your patch may be restored and revised if and when you are ready to continue working on it. Note that a core reviewer may un-abandon a patch to allow subsequent revisions by you or another contributor, as needed.
When making revisions to patches, please acknowledge and confirm each previous review comment as Done or with an explanation for why the comment was not addressed in your subsequent revision.
Includes the Everyone responsibilities, plus:
Recognize that revisions are a normal part of our review process.
Make revisions to your patches to address reviewer comments.
Mark each inline comment as Done once it has been addressed.
Indicate why any requests have not been acted upon.
Set workflow-1 until a patch is ready for merge consideration.
Consider patches without requested revisions as abandoned after a few weeks.
Each reviewer is responsible for upholding the quality of our code. By making constructive and actionable requests for revisions to patches, together we make better software. When making requests for revisions, each reviewer shall carefully consider our aim to merge contributions in a timely manner, while improving them. Contributions do not need to be perfect in order to be merged. You may make comments with a “0” vote to call out stylistic preferences that will not result in a material change to the software if/when resolved.
If a patch improves our code but has been through enough revisions that delaying it further is worse than including it now in imperfect form, you may file a tech-debt bug ticket against the code, and vote to merge the imperfect patch.
When a reviewer requests a revision to a patch, he or she is expected to review the subsequent revision to verify the change addressed the concern.
Includes the Everyone responsibilities, plus:
Uphold quality of our code.
Provide helpful and constructive requests for patch revisions.
Carefully balance need to keep moving while improving contributions.
Submit tech-debt bugs to merge imperfect code with known problems.
Review your requested revisions to verify them.
Core reviewers have all the responsibilities mentioned above, as well as a responsibility to judge the readiness of a patch for merge, and to set the workflow+1 flag to order a patch to be merged once at least one other core reviewers has issued a +2 vote. See: Merge Criteria.
Reviewers who use the -2 vote shall:
Explain what scenarios can/will lift the -2 or downgrade it to a -1 (non-sticky), or explain “this is unmergable for reason <X>”. Non-negotiable reasons such as breaks API contract, or introduces fundamental security issues are acceptable.
Recognize that a -2 needs more justification than a -1 does. Both require actionable notes, but a -2 comment shall outline the reason for the sticky vote rather than a -1.
Closely monitor comments and revisions to that review so the vote is promptly downgraded or removed once addressed by the contributor.
All core reviewers shall be responsible for setting a positive and welcoming tone toward other reviewers and contributors.
Includes the Reviewer responsibilities, plus:
Judge readiness of patches for merge.
Approve patches for merge when requirements are met.
Set a positive and welcoming tone toward other reviewers and contributors.
In accordance with our Project Team Guide for PTLs our PTL carries all the responsibilities referenced above plus:
Select and target blueprints for each release cycle.
Determine Team Consensus. Resolve disagreements among our team.
May delegate his/her responsibilities to others.
- Add and remove core reviewers in accordance with his/her judgement.
Note that in accordance with the Project Team Guide, selection or removal of core reviewers is not a democratic process.
Our PTL shall maintain a core reviewer group that works well together as a team. Our PTL will seek advice from our community when making such changes, but ultimately decides.
Clearly communicate additions to the developer mailing list.
Continuous iterative improvements.
Small contributions preferred.
Perfect is the enemy of good.
We need a compass, not a master plan.
We believe in making continuous iterative improvements to our software. Making several small improvements is preferred over making fewer large changes. Contributions of about perhaps 400 lines of change or less are considered ideal because they are easier to review. This makes them more efficient from a review perspective than larger contributions are, because they get reviewed more quickly, and are faster to revise than larger works. We also encourage unrelated changes to be contributed in separate patches to make reasoning about each one simpler.
Although we should strive for perfection in our work, we must recognize that what matters more than absolute perfection is that our software is consistently improving over time. When contributions are slowed down by too many revisions, we should decide to merge code even when it is imperfect, as long as we have systematically tracked the weaknesses so we can revisit them with subsequent revision efforts.
Our rule of thumb shall be the answer to two simple questions:
Is this patch making Magnum better?
Will this patch cause instability, or prevent others from using Magnum effectively?
If the answers respectively are yes and no, and our objections can be effectively addressed in a follow-up patch, then we should decide to merge code with tech-debt bug tickets to systematically track our desired improvements.
On the Magnum team, we rely on Team Consensus to make key decisions. Team Consensus is the harmonious and peaceful agreement of the majority of our participating team. That means that we seek a clear indication of agreement of those engaged in discussion of a topic. Consensus shall not be confused with the concept of Unanimous Consent where all participants are in full agreement. Our decisions do not require Unanimous Consent. We may still have a team consensus even if we have a small number of team members who disagree with the majority viewpoint. We must recognize that we will not always agree on every key decision. What’s more important than our individual position on an argument is that the interests of our team are met.
We shall take reasonable efforts to address all opposition by fairly considering it before making a decision. Although Unanimous Consent is not required to make a key decision, we shall not overlook legitimate questions or concerns. Once each such concern has been addressed, we may advance to making a determination of Team Consensus.
Some code level changes are controversial in nature. If this happens, and a core reviewer judges the minority viewpoint to be reasonably considered, he or she may conclude we have Team Consensus and approve the patch for merge using the normal voting guidelines. We shall allow reasonable time for discussion and socialization when controversial decisions are considered.
If any contributor disagrees with a merged patch, and believes our decision should be reconsidered, (s)he may consult our Reverting Patches guidelines.
We shall not accept any philosophy of “agree to disagree”. This form of deadlock is not decision making, but the absence of it. Instead, we shall proceed to decision making in a timely fashion once all input has been fairly considered. We shall accept when a decision does not go our way.
When we disagree, we shall first consult the OpenStack Community Code of Conduct for guidance. In accordance with our code of conduct, our disagreements shall be handled with patience, respect, and fair consideration for those who don’t share the same point of view. When we do not agree, we take care to ask why. We strive to understand the reasons we disagree, and seek opportunities to reach a compromise.
Our PTL is responsible for determining Team Consensus when it can not be reached otherwise. In extreme cases, it may be possible to appeal a PTL decision to the OpenStack TC.
One of the four open principles embraced by the OpenStack community is Open Design. We collaborate openly to design new features and capabilities, as well as planning major improvements to our software. We use multiple venues to conduct our design, including:
Mailing list discussions
IRC channel discussion
The above list is ordered by formality level. Notes and/or minutes from meetings shall be recorded in etherpad documents so they can be accessed by participants not present in the meetings. Meetings shall be open, and shall not intentionally exclude any stakeholders.
The most formal venue for open design are written specifications. These are RST format documents that are proposed in the magnum-specs code repository by release cycle name. The repository holds a template for the format of the document, as required by our PTL for each release cycle.
Specifications are intended to be a high level description of a major feature or capability, expressed in a way to demonstrate that the feature has been well contemplated, and is acceptable by Team Consensus. Using specifications allows us to change direction without requiring code rework because input can be considered before code has been written.
Specifications do not require specific implementation details. They shall describe the implementation in enough detail to give reviewers a high level sense of what to expect, with examples to make new concepts clear. We do not require specifications that detail every aspect of the implementation. We recognize that it is more effective to express implementations with patches than conveying them in the abstract. If a proposed patch set for an implementation is not acceptable, we can address such concerns using review comments on those patches. If a reviewer has an alternate idea for implementation, they are welcome to develop another patch in WIP or completed form to demonstrate an alternative approach for consideration. This option for submitting an alternative review is available for alternate specification ideas that reach beyond the scope of a simple review comment. Offering reviewers multiple choices for contributions is welcome, and is not considered wasteful.
Implementations of features do not require merged specifications. However, major features or refactoring should be expressed in a specification so reviewers will know what to expect prior to considering code for review. Contributors are welcome to start implementation before the specifications are merged, but should be ready to revise the implementation as needed to conform with changes in the merged specification.
A review is a patch set that includes a proposal for inclusion in our code base. We follow the process outlined in the Code Review section of the OpenStack Developer’s Guide. The following workflow states may by applied to each review:
Work in progress
This patch is submitted for team input, but should not yet be considered for merge. May be set by a core reviewer as a courtesy. It can be set after workflow+1 but prior to merge in order to prevent a gate breaking merge.
Ready for reviews
This patch should be considered for merge.
This patch has received at least two +2 votes, and is approved for merge. Also known as a “+A” vote.
The following votes may be applied to a review:
We want code to merge relatively quickly in order to keep a rapid pace of innovation. Rather than asking reviewers to wait a prescribed arbitrary time before merging patches, we instead use a simple 2 +2s policy for approving new code for merge. The following criteria apply when judging readiness to merge a patch:
All contributions shall be peer reviewed and approved with a +2 vote by at least two core reviewers prior to being merged. Exceptions known as Fast Merge commits may bypass peer review as allowed by this policy.
The approving reviewer shall verify that all open questions and concerns have been adequately addressed prior to voting +A by adding the workflow+1 to merge a patch. This judgement verifies that Team Consensus has been reached.
Note: We discourage any workflow+1 vote on patches that only have two +2 votes from cores from the same affiliation. This guideline applies when reviewer diversity allows for it.
See Reverting Patches for details about how to remedy mistakes when code is merged too quickly.
Moving quickly with our Merge Criteria means that sometimes we might make mistakes. If we do, we may revert problematic patches. The following options may be applied:
Any contributor may revert a change by submitting a patch to undo the objection and include a reference to the original patch in the commit message. The commit message shall include clear rationale for considering the revert. Normal voting rules apply.
Any contributor may re-implement a feature using an alternate approach at any time, even after a previous implementation has merged. Normal voting rules apply.
If a core reviewer wishes to revert a change (s)he may use the options described above, or may apply the Fast Revert policy.
Sometimes we need to merge code quickly by bypassing the peer review process when justified. Allowed exceptions include:
- PTL (Project Team Lead) Intervention / Core intervention
Emergency un-break gate.
VMT embargoed patch submitted to Gerrit.
Automatic proposals (e.g. requirements updates).
PTL / Core discretion (with comment) that a patch already received a +2 but minor (typo/rebase) fixes were addressed by another core reviewer and the correcting reviewer has opted to carry forward the other +2. The correcting reviewer shall not be the original patch submitter.
We recognize that mistakes may happen when changes are merged quickly. When concerns with any Fast Merge surface, our Fast Revert policy may be applied.
This policy was adapted from nova’s Reverts for Retrospective Vetos policy in 2017. Sometimes our simple 2 +2s approval policy will result in errors when we move quickly. These errors might be a bug that was missed, or equally importantly, it might be that other cores feel that there is a need for further discussion on the implementation of a given piece of code.
Rather than an enforced time-based solution - for example, a patch could not be merged until it has been up for review for 3 days - we have chosen an honor-based system of Team Consensus where core reviewers do not approve controversial patches until proposals are sufficiently socialized and everyone has a chance to raise any concerns.
Recognizing that mistakes can happen, we also have a policy where contentious patches which were quickly approved may be reverted so that the discussion around the proposal may continue as if the patch had never been merged in the first place. In such a situation, the procedure is:
The commit to be reverted must not have been released.
The core team member who has a -2 worthy objection may propose a revert, stating the specific concerns that they feel need addressing.
Any subsequent patches depending on the to-be-reverted patch shall be reverted also, as needed.
Other core team members shall quickly approve the revert. No detailed debate is needed at this point. A -2 vote on a revert is strongly discouraged, because it effectively blocks the right of cores approving the revert from -2 voting on the original patch.
The original patch submitter may re-submit the change, with a reference to the original patch and the revert.
The original reviewers of the patch shall restore their votes and attempt to summarize their previous reasons for their votes.
The patch shall not be re-approved until the concerns of the opponents are fairly considered. A mailing list discussion or design spec may be the best way to achieve this.
This policy shall not be used in situations where Team Consensus was fairly reached over a reasonable period of time. A Fast Revert applies only to new concerns that were not part of the Team Consensus determination when the patch was merged.
See also: Team Consensus.
If any part of this document is not clear, or if you have suggestions for how to improve it, please contact our PTL for help.