From 74baaeba00c90cd7a027e40e2f6d65695341a0e1 Mon Sep 17 00:00:00 2001 From: joey Date: Tue, 21 Aug 2007 04:25:03 +0000 Subject: reorg all the pages about rcs backends. Fix all links --- doc/rcs/details.mdwn | 223 ++++++++++++++++++++++++++++++++++++++++++++ doc/rcs/git.mdwn | 7 ++ doc/rcs/mercurial.mdwn | 8 ++ doc/rcs/monotone.mdwn | 7 ++ doc/rcs/svn.mdwn | 9 ++ doc/rcs/svn/discussion.mdwn | 13 +++ doc/rcs/tla.mdwn | 10 ++ 7 files changed, 277 insertions(+) create mode 100644 doc/rcs/details.mdwn create mode 100644 doc/rcs/git.mdwn create mode 100644 doc/rcs/mercurial.mdwn create mode 100644 doc/rcs/monotone.mdwn create mode 100644 doc/rcs/svn.mdwn create mode 100644 doc/rcs/svn/discussion.mdwn create mode 100644 doc/rcs/tla.mdwn (limited to 'doc/rcs') diff --git a/doc/rcs/details.mdwn b/doc/rcs/details.mdwn new file mode 100644 index 000000000..b9b3c7ead --- /dev/null +++ b/doc/rcs/details.mdwn @@ -0,0 +1,223 @@ +A few bits about the RCS backends + +[[toc ]] + +## Terminology + +``web-edit'' means that a page is edited by using the web (CGI) interface +as opposed to using a editor and the RCS interface. + + +## [[svn]] + +Subversion was the first RCS to be supported by ikiwiki. + +### How does it work internally? + +Master repository M. + +RCS commits from the outside are installed into M. + +There is a working copy of M (a checkout of M): W. + +HTML is generated from W. rcs_update() will update from M to W. + +CGI operates on W. rcs_commit() will commit from W to M. + +For all the gory details of how ikiwiki handles this behind the scenes, +see [[commit-internals]]. + +You browse and web-edit the wiki on W. + +W "belongs" to ikiwiki and should not be edited directly. + + +## [darcs](http://darcs.net/) (not yet included) + +Support for using darcs as a backend is being worked on by [Thomas +Schwinge](mailto:tschwinge@gnu.org), although development is on hold curretly. +There is a patch in [[todo/darcs]]. + +### How will it work internally? + +``Master'' repository R1. + +RCS commits from the outside are installed into R1. + +HTML is generated from R1. HTML is automatically generated (by using a +``post-hook'') each time a new change is installed into R1. It follows +that rcs_update() is not needed. + +There is a working copy of R1: R2. + +CGI operates on R2. rcs_commit() will push from R2 to R1. + +You browse the wiki on R1 and web-edit it on R2. This means for example +that R2 needs to be updated from R1 if you are going to web-edit a page, +as the user otherwise might be irritated otherwise... + +How do changes get from R1 to R2? Currently only internally in +rcs\_commit(). Is rcs\_prepedit() suitable? + +It follows that the HTML rendering and the CGI handling can be completely +separated parts in ikiwiki. + +What repository should [[RecentChanges]] and [[History]] work on? R1? + +#### Rationale for doing it differently than in the Subversion case + +darcs is a distributed RCS, which means that every checkout of a +repository is equal to the repository it was checked-out from. There is +no forced hierarchy. + +R1 is nevertheless called the master repository. It's used for +collecting all the changes and publishing them: on the one hand via the +rendered HTML and on the other via the standard darcs RCS interface. + +R2, the repository the CGI operates on, is just a checkout of R1 and +doesn't really differ from the other checkouts that people will branch +off from R1. + +(To be continued.) + +#### Another possible approach + +Here's what I (tuomov) think, would be a “cleaner” approach: + + 1. Upon starting to edit, Ikiwiki gets a copy of the page, and `darcs changes --context`. + This context _and_ the present version of the page are stored in as the “version” of the + page in a hidden control of the HTML. + Thus the HTML includes all that is needed to generate a patch wrt. to the state of the + repository at the time the edit was started. This is of course all that darcs needs. + 2. Once the user is done with editing, _Ikiwiki generates a patch bundle_ for darcs. + This should be easy with existing `Text::Diff` or somesuch modules, as the Web edits + only concern single files. The reason why the old version of the page is stored in + the HTML (possibly compressed) is that the diff can be generated. + 3. Now this patch bundle is applied with `darcs apply`, or sent by email for moderation… + there are many possibilities. + +This approach avoids some of the problems of concurrent edits that the previous one may have, +although there may be conflicts, which may or may not propagate to the displayed web page. +(Unfortunately there is not an option to `darcs apply` to generate some sort of ‘confliction resolution +bundle’.) Also, only one repository is needed, as it is never directly modified +by Ikiwiki. + +This approach might be applicable to other distributed VCSs as well, although they're not as oriented +towards transmitting changes with standalone patch bundles (often by email) as darcs is. + +> The mercurial plugin seems to just use one repo and edit it directly - is +> there some reason that's okay there but not for darcs? I agree with tuomov +> that having just the one repo would be preferable; the point of a dvcs is +> that there's no difference between one repo and another. I've got a +> darcs.pm based on mercurial.pm, that's almost usable... --bma + +>> IMHO it comes down to whatever works well for a given RCS. Seems like +>> the darcs approach _could_ be done with most any distributed system, but +>> it might be overkill for some (or all?) While there is the incomplete darcs +>> plugin in [[todo/darcs]], if you submit one that's complete, I will +>> probably accept it into ikiwiki.. --[[Joey]] + +## [[Git]] + +Regarding the Git support, Recai says: + +I have been testing it for the past few days and it seems satisfactory. I +haven't observed any race condition regarding the concurrent blog commits +and it handles merge conflicts gracefully as far as I can see. + +As you may notice from the patch size, GIT support is not so trivial to +implement (for me, at least). Being a fairly fresh code base it has some +bugs. It also has some drawbacks (especially wrt merge which was the hard +part). GIT doesn't have a similar functionality like 'svn merge -rOLD:NEW +FILE' (please see the relevant comment in mergepast for more details), so I +had to invent an ugly hack just for the purpose. + +By design, Git backend uses a "master-clone" repository pair approach in contrast +to the single repository approach (here, _clone_ may be considered as the working +copy of a fictious web user). Even though a single repository implementation is +possible, it somewhat increases the code complexity of backend (I couldn't figure +out a uniform method which doesn't depend on the prefered repository model, yet). +By exploiting the fact that the master repo and _web user_'s repo (`srcdir`) are all +on the same local machine, I suggest to create the latter with the "`git clone -l -s`" +command to save disk space. + +Note that, as a rule of thumb, you should always put the rcs wrapper (`post-update`) +into the master repository (`.git/hooks/`) as can be noticed in the Git wrappers of +the sample [[ikiwiki.setup]]. + +## [[Mercurial]] + +The Mercurial backend is still in a early phase, so it may not be mature +enough, but it should be simple to understand and use. + +As Mercurial is a distributed RCS, it lacks the distinction between +repository and working copy (every wc is a repo). + +This means that the Mercurial backend uses directly the repository as +working copy (the master M and the working copy W described in the svn +example are the same thing). + +You only need to specify 'srcdir' (the repository M) and 'destdir' (where +the HTML will be generated). + +Master repository M. + +RCS commit from the outside are installed into M. + +M is directly used as working copy (M is also W). + +HTML is generated from the working copy in M. rcs_update() will update +to the last committed revision in M (the same as 'hg update'). +If you use an 'update' hook you can generate automatically the HTML +in the destination directory each time 'hg update' is called. + +CGI operates on M. rcs_commit() will commit directly in M. + +If you have any question or suggestion about the Mercurial backend +please refer to [Emanuele](http://nerd.ocracy.org/em/) + +## [[tla]] + +## rcs + +There is a patch that needs a bit of work linked to from [[todo/rcs]]. + +## [[Monotone]] + +In normal use, monotone has a local database as well as a workspace/working copy. +In ikiwiki terms, the local database takes the role of the master repository, and +the srcdir is the workspace. As all monotone workspaces point to a default +database, there is no need to tell ikiwiki explicitly about the "master" database. It +will know. + +The backend currently supports normal committing and getting the history of the page. +To understand the parallel commit approach, you need to understand monotone's +approach to conflicts: + +Monotone allows multiple micro-branches in the database. There is a command, +`mtn merge`, that takes the heads of all these branches and merges them back together +(turning the tree of branches into a dag). Conflicts in monotone (at time of writing) +need to be resolved interactively during this merge process. +It is important to note that having multiple heads is not an error condition in a +monotone database. This condition will occur in normal use. In this case +'update' will choose a head if it can, or complain and tell the user to merge. + +For the ikiwiki plugin, the monotone ikiwiki plugin borrows some ideas from the svn ikiwiki plugin. +On prepedit() we record the revision that this change is based on (I'll refer to this as the prepedit revision). When the web user +saves the page, we check if that is still the current revision. If it is, then we commit. +If it isn't then we check to see if there were any changes by anyone else to the file +we're editing while we've been editing (a diff bewteen the prepedit revision and the current rev). +If there were no changes to the file we're editing then we commit as normal. + +It is only if there have been parallel changes to the file we're trying to commit that +things get hairy. In this case the current approach is to +commit the web changes as a branch from the prepedit revision. This +will leave the repository with multiple heads. At this point, all data is saved. +The system then tries to merge the heads with a merger that will fail if it cannot +resolve the conflict. If the merge succeeds then everything is ok. + +If that merge failed then there are conflicts. In this case, the current code calls +merge again with a merger that inserts conflict markers. It commits this new +revision with conflict markers to the repository. It then returns the text to the +user for cleanup. This is less neat than it could be, in that a conflict marked +revision gets committed to the repository. diff --git a/doc/rcs/git.mdwn b/doc/rcs/git.mdwn new file mode 100644 index 000000000..eeb05d5f2 --- /dev/null +++ b/doc/rcs/git.mdwn @@ -0,0 +1,7 @@ +[[meta title="Git"]] + +[Git](http://git.or.cz) is a distributed revison control system originally developed for the Linux kernel. Ikiwiki supports storing a wiki in git. + +Ikiwiki can run as a post-update hook to update a wiki whenever commits +come in. When running as a [[cgi]] with Git, ikiwiki automatically +commits edited pages, and uses the Git history to generate the [[RecentChanges]] page. \ No newline at end of file diff --git a/doc/rcs/mercurial.mdwn b/doc/rcs/mercurial.mdwn new file mode 100644 index 000000000..5eaae1997 --- /dev/null +++ b/doc/rcs/mercurial.mdwn @@ -0,0 +1,8 @@ +[Mercurial](http://selenic.com/mercurial) is a distributed revison control +system developed by Matt Mackall. Ikiwiki supports storing a wiki in a +mercurial repository. + +Ikiwiki can run as a post-update hook to update a wiki whenever commits +come in. When running as a [[cgi]] with Mercurial, ikiwiki automatically +commits edited pages, and uses the Mercurial history to generate the +[[RecentChanges]] page. diff --git a/doc/rcs/monotone.mdwn b/doc/rcs/monotone.mdwn new file mode 100644 index 000000000..d68eb1ed5 --- /dev/null +++ b/doc/rcs/monotone.mdwn @@ -0,0 +1,7 @@ +[monotone](http://monotone.ca/) is a distributed revision control system. +Ikiwiki supports storing a wiki in tla. + +This requires the Monotone perl module from the monotone contrib/ directory +to be installed. In particlar, it needs version 0.03 or higher of that module. +It is available from the monotone source repository at: + diff --git a/doc/rcs/svn.mdwn b/doc/rcs/svn.mdwn new file mode 100644 index 000000000..cd35511c0 --- /dev/null +++ b/doc/rcs/svn.mdwn @@ -0,0 +1,9 @@ +[Subversion](http://subversion.tigris.org/) is a revision control system. While ikiwiki is relatively +independent of the underlying revision control system, and can easily be +used without one, using it with Subversion is recommended since it's how +the author uses it. + +Ikiwiki can run as a [[post-commit]] hook to update a wiki whenever commits +come in. When running as a [[cgi]] with Subversion, ikiwiki automatically +commits edited pages to the subversion repostory, and uses the Subversion +log to generate the [[RecentChanges]] page. diff --git a/doc/rcs/svn/discussion.mdwn b/doc/rcs/svn/discussion.mdwn new file mode 100644 index 000000000..426735182 --- /dev/null +++ b/doc/rcs/svn/discussion.mdwn @@ -0,0 +1,13 @@ +If the user interrupts the page loading during the running of `svn commit`, +the repository will be left in an inconsistent state. The probability of +this happening increases with the size of the repository and the number of +plugins installed, because these both affect how long the post-commit hook +takes to run. (The core issue, I guess, is that we're abusing the concept +of a "working copy" by giving everybody the same one). Here are the main +solutions that I can see: (1) CGI queues commits so that a single process +can act upon them sequentially, or (2) optionally divorce the `ikiwiki +--refresh` from the `svn commit` so that commits happen faster. -- [[Ben]] + +I'm not aware of web servers, at least apache, killing cgi processes when +the user stops a page load. If this is happening ikiwiki should be able to +avoid it by blocking whatever signal is causing it to terminate. --[[Joey]] diff --git a/doc/rcs/tla.mdwn b/doc/rcs/tla.mdwn new file mode 100644 index 000000000..cafd9b49b --- /dev/null +++ b/doc/rcs/tla.mdwn @@ -0,0 +1,10 @@ +[tla](http://wiki.gnuarch.org/) is an implementation of the +[GNU](http://www.gnu.org/) [Arch](http://www.gnuarch.org/) revision control +system. Ikiwiki supports storing a wiki in tla. + +Ikiwiki can run as a [[post-commit]] hook to update a wiki whenever commits +come in. When running as a [[cgi]] with tla, ikiwiki automatically +commits edited pages to the Arch repostory, and uses the Arch +log to generate the [[RecentChanges]] page. + +Note that the tla support needs the [[cpan MailTools]] perl module. -- cgit v1.2.3