From Fedora Project Wiki

Revision as of 18:15, 1 March 2010 by James (talk | contribs) (Add my proposal, user choice)

This page is a start at defining expectations for updating packages within the release. It's current aim is to document what people want, what we have now, and making proposals in how to change what we have now to satisfy more people more of the time.

Update styles

These are the update styles that people have expressed as wanting.

  • Rolling -- This is essentially what our current no-frozen-rawhide is. Every packager can update their packages whenever they want. Although breakage is discouraged, breakage can occur with some regularity due to packages being upgraded while their dependent packages are not, the inherent greater risk of regression in the updates occurring in rawhide, and the current world where updates in rawhide are not always tested by the people who are packaging. Updates to new major versions are expected. Note: no one has expressed a desire to consume this.
  • Semi-rolling -- This is the current practice of the KDE SIG. Major updates do occur but they are worked on as a set to avoid breaking deps. The updates undergo extensive testing (KDE SIG pushes the packages through kde-redhat, rawhide, and updates-testing before they hit updates repo) before going to stable. Critical bugfixes and bugfixes evaluated as low risk are pushed directly to stable. Other changes (enhancements, for instance) are pushed through updates-testing first. There is a proposal that rawhide should somehow be moved to a more semi-rolling model so that people would be willing to consume it directly instead of pushing changes to released Fedoras.
  • QA'd -- This is a large category that we may want to break into further subdivisions. It includes separate proposals to force updates to go through updates-testing first, forced updates-testing with exceptions for low risk updates and critical fix updates, simply adding AutoQA tests that must be passed to go to updates, requiring some amount of karma before a package can go to updates. (feel free to list others)
  • Critical bugfix-only -- this style only allows critical bugfixes (including security updates) to go to updates. Note that in Fedora, this would likely drag in some enhancements due to package dependencies and no requirement to backport. An extreme example of this is the practice employed by updates to a RHEL-5.N release (and to a lesser extent by RHEL5.N to 5-M).

Additional Considerations

Feel free to add more additional considerations here
  • Backporting -- Fedora does not currently require backporting of fixes. This means that in any style of update, a fix to one package could require updating other packages due to changes in the fixed package.
  • Should new packages be considered as a special case of updates to existing packages and therefore have different rules?

Present lifecycle

Fill in definitions and have jkeating review for accuracy
  • Rawhide -- Anyone can submit a package at any time. Breakage is discouraged but in practice does occur. There is no testing repository, updates go directly into rawhide. Packages built are available for building against very shortly afterwards. Rawhide is composed once a night with possibly broken deps across packages if people are in the middle of a multipackage rebuild. Koji tags have been used for some large updates to try to mitigate the latter.
  • Alpha -- begin to use bodhi with updates-testing repo ("stable" updates go to the actual release tree). Major features should be in place but backwards incompatible changes can still occur. critpath packages get more scrutiny (need to be acked by releng) than non-critpath packages.
  • Beta
  • Preview
  • Release/F-Current
  • F-(Current-1)
  • F-(Current-2)
  • EOL -- from the yum update numbers, EOL is a reasonably active time for users even though there isn't any further development for maintainers.

Areas that we can change

  • Length of time in updates-testing
  • Review of update submission
  • Where people start being able to use a release
  • Criteria for making an update
  • Requirement to backport
  • Define different policies for F-Current, F-Current-1, and F-current-2
  • Change the EOL time frame
  • Enforce different policies on rawhide
  • AutoQA test requirements
  • Multiple update streams (security, bugfix, enhancement)
  • Different policy for critpath (or other subset of important/popular packages)

Technical things that can help

  • Program to make submitting karma to bodhi very easy
  • Program to get more users selectively using updates-testing
  • Previous two as tabs in packagekit
  • Mark package updates with type (security, critical bug, major bug, minor bug, enhancement, etc) and have a yum plugin to allow clients to filter for the updates they want (note that the packages must still satisfy dependencies so a security fix may pull in various enhancements via package deps.)
  • Have updates be placed into a set and pushed on a weekly/biweekly/monthly schedule so that QA can be run over a complete update set.
  • More repositories that have different policies
  • Make it easy to use different build tags in koji (tag to rebuild a set of packages and their dependencies. Once the rebuild is done, push it back into the main tree.)
  • The Bugzilla comments that Bodhi sends probably need some work. They're currently very complete and factual but they don't include any information for the less experienced users who are often filing bugs. Those people have reached out to contribute something, they want to continue that engagement (i.e. get a fix), and we could have a mutually positive exchange with them. By not giving them clear information we're putting that opportunity at risk. (stickster)
  • A notification mechanism for people to opt-in to. If they have a package installed that has known bugs. The notification mechanism should "pleasantly coerce" the user to test, but letting them know we can't promise it will work. If it doesn't, our tools should be able to undo that transaction gracefully -- start from current updates, try test, if failing 'yum history undo' back to current update. (stickster)
  • Being able to achieve karma right after the build is done (jkeating) (is this already doable in bodhi?)
  • Better description for bodhi-client package; enhance bodhi-client man page to show how end-users can use it to comment (if that's possible ATM)


Pull in other proposals, have kkofler review the semi-rolling proposal. Format the proposals to wiki syntax

Semi-rolling (kkofler)

Because that comes with some types of disruptive changes which we do not
perform in releases and which I do not advocate performing in releases.
Rolling releases like Rawhide, Debian unstable, Gentoo etc. have no set
points to do disruptive changes. So e.g. you wake up in the morning and your
system no longer boots because your kernel upgrade from yesterday enabled
libata and you had hd* hardcoded in some place. (Yes, I know that particular
change is now a done deal, but there will definitely be similar changes in
the future.)

As I have explained several times, AIUI, a stable release MUST NOT get
upgrades which "break things", e.g.:
* require manual adjustment to config files, databases etc.,
* break support for existing user data (documents, configuration, savegames
* knowingly introduce regressions,
* remove features,
* radically change the UI (but I don't think minor changes like a menu entry
moving to a different place are a serious issue),
* bump the soname of a core library on which dozens of packages depend (but
I don't personally see a grouped update with a soname change and a rebuild
of ALL packages using that library as a problem as long as it's only for a
few packages),
* change the API of a library in a way that existing applications using it
fail to rebuild and cannot easily be fixed (in fact soname bumps MUST be
accompanied by rebuilds of everything affected)
etc. (and I think we all agree there. But that's why Rawhide is not the
answer!), but IMHO (and there opinions differ), it SHOULD get upgrades
* fix bugs, even if they're not critical or security,
* introduce features in a non-disruptive, backwards-compatible way (e.g.
there's now a new menu entry which does something cool, at worst that new
menu entry might not work perfectly, but it shouldn't affect anything else).

Snapshot (mmcgrath)

The idea behind this proposal is that when we release a new Fedora, it is a snapshot of rawhide at that time. Throughout its life-cycle, it should stay as close to that snapshot as feasible until it is EOLed. The policy is simple and quick to read. As a user I know what to expect from this policy and as a packager I know what is expected of me.

This will slow down updates on stable releases and allow developers / packagers to focus on the next release.

Stable Releases

  • Enhancement-only updates would be discouraged.
  • Backporting is preferred but understand not everyone has the time/know how to do it.
  • We could treat crit path packages with even more scrutiny
  • We could create a list of update types that we would not allow. For example: Fixing a br, license change, added doc, etc.
  • Bug and security should be examined to determine if they actually impact Fedora and it would be up to the packager to decide if the update was worth the risk to our users or not.

Special notes for rawhide updates:

  • Anything that does not knowingly break things is fair game
  • Things that require manual changes need to get sent / notified to the user (do we need to invent a mechanism for this?
  • Such changes should end up in the release notes
  • Changes which knowingly break things should be reported to the list/ announced with a timeline and rollback procedure.

Note: I'm not actually on FESCo so if people have a problem with that and ignore my proposal I won't take it personally ;-)

Choice (james)

Give the users choice, and do the expected thing by default

The idea behind this proposal is that a Fedora user installing a release N has a lot of choice if they wish to get newer packages:

  • They can move to rawhide.
  • They can install specific packages from rawhide.
  • With NFR, they can now move to a pre-release of N+1.
  • They can install specific packages from N+1.
  • They can enable updates-testing.
  • They can install specific packages from updates-testing.
  • If they are on an older Fedora release, they can update to the latest Fedora release.

...but they have almost no options if they are happy to stay with the software that they have. It's also a common user expectation that updates within a release are mainly to fix bugs, and even then very minor bugs might not get fixed (but, if you need it fixed you have lots of choice above).

The way to add choice is to lower the numbers of updates that a user would see by default, and to lower the number of changes that those updates contain. This should be obvious, if you have 500 pending updates there is little choice but to just update everything and hope for the best. In the same way if a package contains 3-6 months of upstream changes then the user just has to hope for the best.

Due to the fact that Fedora cannot reward packagers for doing backports, or employ more developers, the only real option we have is to "punish" the kinds of updates which remove choice from our users. This will likely mean that some updates might not happen, that users would want if they looked at it independtly. But this is exected, as above, and as a known general rule perfect is the enemy of good.


We deal with everything in "days spent in updates-testing" (DSUT). For each package this starts out at 4 days, which is roughly enough for the package to make it into a compose it to get to most of the mirrors and for interested users to easily test it. Each time a package moves from updates-testing => updates the DSUT for that package is doubled. So on the third update for a package the DSUT would be 16 days, however putting an updated package into updates-testing three times would keep the DSUT at 4 days.

For the current stable release we then apply a number of DSUTs to an update, depending on how complicated it is:

  • High severity security bugs would get treated mostly as they do now, there would hopefully be more resources to backport fixes instead of rebasing ... but we need to get those out quickly, so they would have 0 DSUT.
  • Lower severity security bugs would get 1 DSUT.
  • New packages would get 2 DSUT.
  • Backport fixes would have 3 DSUT.
  • Fixes which include some new features (Eg. a minor upstream rebase, which is mostly fixes) would have 5 DSUT.
  • Updates which contain lots of features/improvements (which may, or may not contain bug fixes) would havbe 10 DSUT.
  • Any update not containing enough errata information to easily fit into one of the above slots would get 20 DSUT. This would include update information like "updating to upstream version 2.4.8".

Older stable release would be dealt with using a simple rule "all updates must first be in a newer release". This does mean that if you want to update to the version released in the current stable Fedora, it works just as above. This has a number of nice features allowing significantly tested packages that don't change much to easily make it back to older releases without causing any update problems.

While this may seem "complicated" the outcome of the above should be very simple, and be very close to what users expect. Namely that packages will not update many times and will contain less changes.

Also note that there are no restrictions on packages in updates-testing, as that would not improve choice, so anyone who wants a much faster moving Fedora can just enable updates-testing (or install specific parts of it).

What other distros do

This section is informational only. Fedora should neither do something listed here to copy another distro nor avoid something here because other distros do it. This can be a place to draw ideas from but whether they make sense Fedora depends on how they map to Fedora's goals and the needs of people consuming updates