|
Size: 8636
Comment:
|
Size: 516
Comment:
|
| Deletions are marked like this. | Additions are marked like this. |
| Line 1: | Line 1: |
| #pragma section-numbers 2 = Phases = <<TableOfContents>> == Introduction == The phase concept improves safety of history rewriting and control over changesets exchanged ([[#Available_Phases|read more]]). This phase concept aims to "just works" in a transparent manner for any user ([[#Phase_Movements|read more]]). It is part of Core and always enabled in any new client but doesn't prevent older client to work on a repository ([[#Upgrade_Notes|read more]]). Advanced user may decides to handle phase manually ([[#Publishing_Repository|read more]]). Like bookmarks, phases are not stored in history and thus are not permanent and leave no audit trail. This concept is introduced in Mercurial 2.1. == Available Phases == The phase concept allow to: * Prevent accidental rewriting part of the history expected to be immutable. * Keep immature changeset to be exchanged by mistake. To achieve this, are three phases sharing a hierarchy of traits: || ||immutable ||shared || ||public ||x ||x || ||draft || ||x || ||secret || || || * '''The public phases''' holds changeset announced publicly in. They are expect to . always exists in your history and are said ''immutable''. History rewriting extension will refuse to delete such '''immutable''' changeset. Every changeset your push or pull from a public server are set in this phase. * '''The draft phase''' holds changesets that was not expect marked as part of . the permanent history. You can safely rewrite them. New commit are draft by default. * '''The secret phase''' holds changeset that you do not want to exchange with . other repository. Secret changeset are hidden to remote peer and won't be included in push operation. Manual operation or Extension may turn changeset secret. Phases split the history in coherent set of changeset. Every changeset in a phase have ancestor in a phase ''compatible'' with its phase. ''Compatible'' means an changeset ancestors have at least the same traits that the children changeset. eg: A ''shared'' changeset alway have ''shared'' ancestor and an ''immutable'' changeset always have ''immutable'' ancestors. In other word the phase of a changeset is alway equal of higher that the phase of it's descendant. According to the following order: . public < draft < secret A changeset is not expected to automatically move from a lower phase to an higher phase (eg: from ''public'' to ''draft'') but automatic == Phase Movements == Phase movement are automatic and transparent and most user don't have to care much about them. The base rule is very simple: . “''Any changesets on a remote repository is seen a public''” On standard exchange commands, the phase of changesets on both side are compared. If differ the lowest phase is choosed. (eg: a changeset known as ''draft'' locally but '''public''' remotely is set public localy. Because public < draft) This update happen during standard exchange commands: * '''pull''': remote phase data are used to update the phase data on . the local repo. As pull is read only, it does not change changeset's phase on the remote * '''push''': remote phase data are used to the phase data on the local repo and . then local phase data are pushed to the local repo. The real behavior is a it's a bit more complicated than '' changesets on a remote repository is seen a public'', but this is true for repository keeping default . If you need a finer behavior, consult the ''[[#Publishing_Repository|publishing repository]]'' section. New changeset committed locally are ''draft'', but some extension like ''mq'' may create ''secret'' and handle the move from ''secret'' to ''draft'' automatically Consult the [[#upgrade_Notes]] section to check how phase will move the first time a new version of Mercurial touch and existing repository. == command line interface == === core command === === impact on extension === == Publishing Repository == By default any changeset exchanged over the wire are set public. Advanced user may want a finer behavior. The Publishing repository concept is designed for this purpose. ==== What is a "publishing repository"? ==== Setting a repository as "publishing" alter its behavior **when used as a server**: all changesets are **seen** as public changesets by clients. So, pushing to a "publishing" repository is the most common way to make changesets public: pushed changesets are seen as public on the remote side and marked as such on local side. Note: the "publishing" property have no effects for local operations. ==== Old repository are publishing ==== Phase is the first step of a series of features aiming at handling mutable history within mercurial. Old client do not support such feature and are unable to hold phase data. The safest solution is to consider as public any changeset going through an old client. Moreover, most hosting solution will not support phase from the beginning. Having old clients seen as public repositories will not change their usage: public repositories where you push *immutable* public changesets *shared* with others. ==== Why is "publishing" the default? ==== We discussed above that any changeset from a non-phase aware repository should be seen as public. This means that in the following scenario, X is pulled as public:: {{{ ~/A$ cd ../B ~/B$ new-hg pull ../A # let's pretend A is served by old-hg ~/B$ new-hg log -r tip summary: X phase: public }}} We want to keep this behavior while creating/serving the A repository with new-hg. Although committing with any new-hg creates a draft changeset. To stay backward compatible, the pull must see the new commit as public. Non-publishing server will advertise them as draft. Having publishing repository the default is thus necessary to ensure this backward compatibility. This default value can also be expressed with the following sentence: "By default, without any configuration, everything you exchange with the outside is immutable.". This behaviour seems sane. ==== Why allow draft changeset in publishing repository ==== Note: The publish option is aimed at controlling the behavior of ''server''. Changeset in any state on a publishing server will '''always''' be seen as public by other client. "Passive" repository which are only used as server for pull and push operation are not "affected" by this section. As in the choice for default, the main reason to allow draft changeset in publishing server is backward compatibility. With an old client, the following scenario is valid:: {{{ ~/A$ old-hg init ~/A$ echo 'babar' > jungle ~/A$ old-hg commit -mA 'X' ~/A$ old-hg qimport -r . # or any other mutable operation on X }}} '' '' If the default is publishing and new commits in such repository are "''public''" The following operation will be denied as X will be an '''immutable''' public changeset. However as other clients see X as public, any pull//push (or event pull//pull) will mark X as ''public'' in repo A. == Upgrade Notes == The important point to are: * repository with phase data can still accessed by old client * new client will add phase data to any repository it touch * If everything you plan to mutate is mq handled you don't have to care about anything. === Backward Compatility === Phase data are stored in a new files and does not alter any part of the existing mercurial repository format. This means that a new client can safely write phase related data without preventing an old client to works with the repository. This allow new client store and handle phase related logic on **all repository**. === Adding phase data to old repo === There are a lot a repository out there with plenty of changeset but yet any phase data. When looking at such repository, a new client take the safe road and decided everything is 'public'. Some extension register logic to tune this choice. For example, mq set every changeset under it's control as secret in this situation. You can set all changesets not pushed to a repository in the draft phase again using: {{{ hg phase --force --draft 'children(remote())' }}} === Adding phase data to old repo === Beware that and old client won't be able to move phase when touching a repo. * An old client can mutable immutable changesets * An old client will push secret changeset * An old client will commit new changeset in the phase of their parent * An old client add changeset in the phase of their parent. (If you were looking to the developer oriented page: PhaseDevel) |
Tiny Boysen is what's written on brand new birth certificate horrifying than feel comfortable if you wish to use the owner's name. For years I've only been working as a real postal service wood worker. Some time ago I picked to live in Wyoming. My husband does not mean like it during I do while what I adore doing is to build up badges and now i'm trying to building an income with it. I've been working on my brand new website for some time now. Check against eachother here: http://ri.ms/www.videohomefinder.com |
Tiny Boysen is what's written on brand new birth certificate horrifying than feel comfortable if you wish to use the owner's name. For years I've only been working as a real postal service wood worker. Some time ago I picked to live in Wyoming. My husband does not mean like it during I do while what I adore doing is to build up badges and now i'm trying to building an income with it. I've been working on my brand new website for some time now. Check against eachother here: http://ri.ms/www.videohomefinder.com