ikiwiki (3.20130711) unstable; urgency=low
[ikiwiki.git] / doc / tips / convert_mediawiki_to_ikiwiki / discussion.mdwn
1 20100428 - I just wrote a simple ruby script which will connect to a mysql server and then recreate the pages and their revision histories with Grit. It also does one simple conversion of equals titles to pounds. Enjoy! 
2
3 <http://github.com/docunext/mediawiki2gitikiwiki>
4
5 -- [[users/Albert]]
6
7 ----
8
9 I wrote a script that will download all the latest revisions of a mediawiki site. In short, it does a good part of the stuff required for the migration: it downloads the goods (ie. the latest version of every page, automatically) and commits the resulting structure. There's still a good few pieces missing for an actual complete conversion to ikiwiki, but it's a pretty good start. It only talks with mediawiki through HTTP, so no special access is necessary. The downside of that is that it will not attempt to download every revision for performance reasons. The code is here: git://anarcat.ath.cx/software/mediawikigitdump.git/ and git://anarcat.ath.cx/software/media2iki.git/ See header of the file for more details and todos. -- [[users/Anarcat]] 2010-10-15
10
11 ----
12
13 The u32 page is excellent, but I wonder if documenting the procedure here
14 would be worthwhile. Who knows, the remote site might disappear. But also
15 there are some variations on the approach that might be useful:
16
17  * using a python script and the dom library to extract the page names from
18    Special:Allpages (such as
19    <http://www.staff.ncl.ac.uk/jon.dowland/unix/docs/get_pagenames.py>)
20  * Or, querying the mysql back-end to get the names
21  * using WWW::MediaWiki for importing/exporting pages from the wiki, instead
22    of Special::Export
23
24 Also, some detail on converting mediawiki transclusion to ikiwiki inlines...
25
26 -- [[users/Jon]]
27
28 ----
29
30 > "Who knows, the remote site might disappear.". Right now, it appears to
31 > have done just that. -- [[users/Jon]]
32
33 I have manage to recover most of the site using the Internet Archive. What
34 I was unable to retrieve I have rewritten. You can find a copy of the code
35 at <http://github.com/mithro/media2iki>
36
37 > This is excellent news. However, I'm still keen on there being a
38 > comprehensive and up-to-date set of instructions on *this* site. I wouldn't
39 > suggest importing that material into ikiwiki like-for-like (not least for
40 > [[licensing|freesoftware]] reasons), but it's excellent to have it available
41 > for reference, especially since it (currently) is the only set of
42 > instructions that gives you the whole history.
43
44 > The `mediawiki.pm` that was at u32.net is licensed GPL-2. I'd like to see it
45 > cleaned up and added to IkiWiki proper (although I haven't requested this
46 > yet, I suspect the way it (ab)uses linkify would disqualify it at present).
47 >
48 > I've imported Scott's initial `mediawiki.pm` into a repository at
49 > <http://github.com/jmtd/mediawiki.pm> as a start.
50 > -- [[Jon]]
51
52 ----
53
54 The iki-fast-load ruby script from the u32 page is given below:
55
56         #!/usr/bin/env ruby
57
58         # This script is called on the final sorted, de-spammed revision
59         # XML file.
60         #
61         # It doesn't currently check for no-op revisions...  I believe
62         # that git-fast-load will dutifully load them even though nothing
63         # happened.  I don't care to solve this by adding a file cache
64         # to this script.  You can run iki-diff-next.rb to highlight any
65         # empty revisions that need to be removed.
66         #
67         # This turns each node into an equivalent file.
68         #    It does not convert spaces to underscores in file names.
69         #       This would break wikilinks.
70         #       I suppose you could fix this with mod_speling or mod_rewrite.
71         #
72         # It replaces nodes in the Image: namespace with the files themselves.
73
74
75         require 'rubygems'
76         require 'node-callback'
77         require 'time'
78         require 'ostruct'
79
80
81         # pipe is the stream to receive the git-fast-import commands
82         # putfrom is true if this branch has existing commits on it, false if not.
83         def format_git_commit(pipe, f)
84            # Need to escape backslashes and double-quotes for git?
85            # No, git breaks when I do this. 
86            # For the filename "path with \\", git sez: bad default revision 'HEAD'
87            # filename = '"' + filename.gsub('\\', '\\\\\\\\').gsub('"', '\\"') + '"'
88
89            # In the calls below, length must be the size in bytes!!
90            # TODO: I haven't figured out how this works in the land of UTF8 and Ruby 1.9.
91            pipe.puts "commit #{f.branch}"
92            pipe.puts "committer #{f.username} <#{f.email}> #{f.timestamp.rfc2822}"
93            pipe.puts "data #{f.message.length}\n#{f.message}\n"
94            pipe.puts "from #{f.branch}^0" if f.putfrom
95            pipe.puts "M 644 inline #{f.filename}"
96            pipe.puts "data #{f.content.length}\n#{f.content}\n"
97            pipe.puts
98         end
99
100 > Would be nice to know where you could get "node-callbacks"... this thing is useless without it. --[[users/simonraven]]
101
102
103 Mediawiki.pm - A plugin which supports mediawiki format.
104
105         #!/usr/bin/perl
106         # By Scott Bronson.  Licensed under the GPLv2+ License.
107         # Extends Ikiwiki to be able to handle Mediawiki markup.
108         #
109         # To use the Mediawiki Plugin:
110         # - Install Text::MediawikiFormat
111         # - Turn of prefix_directives in your setup file.
112         #     (TODO: we probably don't need to do this anymore?)
113         #        prefix_directives => 1,
114         # - Add this plugin on Ikiwiki's path (perl -V, look for @INC)
115         #       cp mediawiki.pm something/IkiWiki/Plugin
116         # - And enable it in your setup file
117         #        add_plugins => [qw{mediawiki}],
118         # - Finally, turn off the link plugin in setup (this is important)
119         #        disable_plugins => [qw{link}],
120         # - Rebuild everything (actually, this should be automatic right?)
121         # - Now all files with a .mediawiki extension should be rendered properly.
122         
123         
124         package IkiWiki::Plugin::mediawiki;
125         
126         use warnings;
127         use strict;
128         use IkiWiki 2.00;
129         use URI;
130         
131         
132         # This is a gross hack...  We disable the link plugin so that our
133         # linkify routine is always called.  Then we call the link plugin
134         # directly for all non-mediawiki pages.  Ouch...  Hopefully Ikiwiki
135         # will be updated soon to support multiple link plugins.
136         require IkiWiki::Plugin::link;
137         
138         # Even if T:MwF is not installed, we can still handle all the linking.
139         # The user will just see Mediawiki markup rather than formatted markup.
140         eval q{use Text::MediawikiFormat ()};
141         my $markup_disabled = $@;
142         
143         # Work around a UTF8 bug in Text::MediawikiFormat
144         # http://rt.cpan.org/Public/Bug/Display.html?id=26880
145         unless($markup_disabled) {
146            no strict 'refs';
147            no warnings;
148            *{'Text::MediawikiFormat::uri_escape'} = \&URI::Escape::uri_escape_utf8;
149         }
150         
151         my %metaheaders;    # keeps track of redirects for pagetemplate.
152         my %tags;      # keeps track of tags for pagetemplate.
153         
154         
155         sub import { #{{{
156            hook(type => "checkconfig", id => "mediawiki", call => \&checkconfig);
157            hook(type => "scan", id => "mediawiki", call => \&scan);
158            hook(type => "linkify", id => "mediawiki", call => \&linkify);
159            hook(type => "htmlize", id => "mediawiki", call => \&htmlize);
160            hook(type => "pagetemplate", id => "mediawiki", call => \&pagetemplate);
161         } # }}}
162         
163         
164         sub checkconfig
165         {
166            return IkiWiki::Plugin::link::checkconfig(@_);
167         }
168         
169         
170         my $link_regexp = qr{
171             \[\[(?=[^!])        # beginning of link
172             ([^\n\r\]#|<>]+)      # 1: page to link to
173             (?:
174                 \#              # '#', beginning of anchor
175                 ([^|\]]+)       # 2: anchor text
176             )?                  # optional
177         
178             (?:
179                 \|              # followed by '|'
180                 ([^\]\|]*)      # 3: link text
181             )?                  # optional
182             \]\]                # end of link
183                 ([a-zA-Z]*)   # optional trailing alphas
184         }x;
185         
186         
187         # Convert spaces in the passed-in string into underscores.
188         # If passed in undef, returns undef without throwing errors.
189         sub underscorize
190         {
191            my $var = shift;
192            $var =~ tr{ }{_} if $var;
193            return $var;
194         }
195         
196         
197         # Underscorize, strip leading and trailing space, and scrunch
198         # multiple runs of spaces into one underscore.
199         sub scrunch
200         {
201            my $var = shift;
202            if($var) {
203               $var =~ s/^\s+|\s+$//g;      # strip leading and trailing space
204               $var =~ s/\s+/ /g;      # squash multiple spaces to one
205            }
206            return $var;
207         }
208         
209         
210         # Translates Mediawiki paths into Ikiwiki paths.
211         # It needs to be pretty careful because Mediawiki and Ikiwiki handle
212         # relative vs. absolute exactly opposite from each other.
213         sub translate_path
214         {
215            my $page = shift;
216            my $path = scrunch(shift);
217         
218            # always start from root unless we're doing relative shenanigans.
219            $page = "/" unless $path =~ /^(?:\/|\.\.)/;
220         
221            my @result = ();
222            for(split(/\//, "$page/$path")) {
223               if($_ eq '..') {
224                  pop @result;
225               } else {
226                  push @result, $_ if $_ ne "";
227               }
228            }
229         
230            # temporary hack working around http://ikiwiki.info/bugs/Can__39__t_create_root_page/index.html?updated
231            # put this back the way it was once this bug is fixed upstream.
232            # This is actually a major problem because now Mediawiki pages can't link from /Git/git-svn to /git-svn.  And upstream appears to be uninterested in fixing this bug.  :(
233            # return "/" . join("/", @result);
234            return join("/", @result);
235         }
236         
237         
238         # Figures out the human-readable text for a wikilink
239         sub linktext
240         {
241            my($page, $inlink, $anchor, $title, $trailing) = @_;
242            my $link = translate_path($page,$inlink);
243         
244            # translate_path always produces an absolute link.
245            # get rid of the leading slash before we display this link.
246            $link =~ s#^/##;
247         
248            my $out = "";
249            if($title) {
250                $out = IkiWiki::pagetitle($title);
251            } else {
252               $link = $inlink if $inlink =~ /^\s*\//;
253                $out = $anchor ? "$link#$anchor" : $link;
254               if(defined $title && $title eq "") {
255                  # a bare pipe appeared in the link...
256                  # user wants to strip namespace and trailing parens.
257                  $out =~ s/^[A-Za-z0-9_-]*://;
258                  $out =~ s/\s*\(.*\)\s*$//;
259               }
260               # A trailing slash suppresses the leading slash
261               $out =~ s#^/(.*)/$#$1#;
262            }
263            $out .= $trailing if defined $trailing;
264            return $out;
265         }
266         
267         
268         sub tagpage ($)
269         {
270            my $tag=shift;
271         
272            if (exists $config{tagbase} && defined $config{tagbase}) {
273               $tag=$config{tagbase}."/".$tag;
274            }
275         
276            return $tag;
277         }
278         
279         
280         # Pass a URL and optional text associated with it.  This call turns
281         # it into fully-formatted HTML the same way Mediawiki would.
282         # Counter is used to number untitled links sequentially on the page.
283         # It should be set to 1 when you start parsing a new page.  This call
284         # increments it automatically.
285         sub generate_external_link
286         {
287            my $url = shift;
288            my $text = shift;
289            my $counter = shift;
290         
291            # Mediawiki trims off trailing commas.
292            # And apparently it does entity substitution first.
293            # Since we can't, we'll fake it.
294         
295            # trim any leading and trailing whitespace
296            $url =~ s/^\s+|\s+$//g;
297         
298            # url properly terminates on > but must special-case &gt;
299            my $trailer = "";
300            $url =~ s{(\&(?:gt|lt)\;.*)$}{ $trailer = $1, ''; }eg;
301         
302            # Trim some potential trailing chars, put them outside the link.
303            my $tmptrail = "";
304            $url =~ s{([,)]+)$}{ $tmptrail .= $1, ''; }eg;
305            $trailer = $tmptrail . $trailer;
306         
307            my $title = $url;
308            if(defined $text) {
309               if($text eq "") {
310                  $text = "[$$counter]";
311                  $$counter += 1;
312               }
313               $text =~ s/^\s+|\s+$//g;
314               $text =~ s/^\|//;
315            } else {
316               $text = $url;
317            }
318         
319            return "<a href='$url' title='$title'>$text</a>$trailer";
320         }
321         
322         
323         # Called to handle bookmarks like \[[#heading]] or <span class="createlink"><a href="http://u32.net/cgi-bin/ikiwiki.cgi?page=%20text%20&amp;from=Mediawiki_Plugin%2Fmediawiki&amp;do=create" rel="nofollow">?</a>#a</span>
324         sub generate_fragment_link
325         {
326            my $url = shift;
327            my $text = shift;
328         
329            my $inurl = $url;
330            my $intext = $text;
331            $url = scrunch($url);
332         
333            if(defined($text) && $text ne "") {
334               $text = scrunch($text);
335            } else {
336               $text = $url;
337            }
338         
339            $url = underscorize($url);
340         
341            # For some reason Mediawiki puts blank titles on all its fragment links.
342            # I don't see why we would duplicate that behavior here.
343            return "<a href='$url'>$text</a>";
344         }
345         
346         
347         sub generate_internal_link
348         {
349            my($page, $inlink, $anchor, $title, $trailing, $proc) = @_;
350         
351            # Ikiwiki's link link plugin wrecks this line when displaying on the site.
352            # Until the code highlighter plugin can turn off link finding,
353            # always escape double brackets in double quotes: \[[
354            if($inlink eq '..') {
355               # Mediawiki doesn't touch links like \[[..#hi|ho]].
356               return "\[[" . $inlink . ($anchor?"#$anchor":"") .
357                  ($title?"|$title":"") . "]]" . $trailing;
358            }
359         
360            my($linkpage, $linktext);
361            if($inlink =~ /^ (:?) \s* Category (\s* \: \s*) ([^\]]*) $/x) {
362               # Handle category links
363               my $sep = $2;
364               $inlink = $3;
365               $linkpage = IkiWiki::linkpage(translate_path($page, $inlink));
366               if($1) {
367                  # Produce a link but don't add this page to the given category.
368                  $linkpage = tagpage($linkpage);
369                  $linktext = ($title ? '' : "Category$sep") .
370                     linktext($page, $inlink, $anchor, $title, $trailing);
371                  $tags{$page}{$linkpage} = 1;
372               } else {
373                  # Add this page to the given category but don't produce a link.
374                  $tags{$page}{$linkpage} = 1;
375                  &$proc(tagpage($linkpage), $linktext, $anchor);
376                  return "";
377               }
378            } else {
379               # It's just a regular link
380               $linkpage = IkiWiki::linkpage(translate_path($page, $inlink));
381               $linktext = linktext($page, $inlink, $anchor, $title, $trailing);
382            }
383         
384            return &$proc($linkpage, $linktext, $anchor);
385         }
386         
387         
388         sub check_redirect
389         {
390            my %params=@_;
391         
392            my $page=$params{page};
393            my $destpage=$params{destpage};
394            my $content=$params{content};
395         
396            return "" if $page ne $destpage;
397         
398            if($content !~ /^ \s* \#REDIRECT \s* \[\[ ( [^\]]+ ) \]\]/x) {
399               # this page isn't a redirect, render it normally.
400               return undef;
401            }
402         
403            # The rest of this function is copied from the redir clause
404            # in meta::preprocess and actually handles the redirect.
405         
406            my $value = $1;
407            $value =~ s/^\s+|\s+$//g;
408         
409            my $safe=0;
410            if ($value !~ /^\w+:\/\//) {
411               # it's a local link
412               my ($redir_page, $redir_anchor) = split /\#/, $value;
413         
414               add_depends($page, $redir_page);
415               my $link=bestlink($page, underscorize(translate_path($page,$redir_page)));
416               if (! length $link) {
417                  return "<b>Redirect Error:</b> <nowiki>\[[$redir_page]] not found.</nowiki>";
418               }
419         
420               $value=urlto($link, $page);
421               $value.='#'.$redir_anchor if defined $redir_anchor;
422               $safe=1;
423         
424               # redir cycle detection
425               $pagestate{$page}{mediawiki}{redir}=$link;
426               my $at=$page;
427               my %seen;
428               while (exists $pagestate{$at}{mediawiki}{redir}) {
429                  if ($seen{$at}) {
430                     return "<b>Redirect Error:</b> cycle found on <nowiki>\[[$at]]</nowiki>";
431                  }
432                  $seen{$at}=1;
433                  $at=$pagestate{$at}{mediawiki}{redir};
434               }
435            } else {
436               # it's an external link
437               $value = encode_entities($value);
438            }
439         
440            my $redir="<meta http-equiv=\"refresh\" content=\"0; URL=$value\" />";
441            $redir=scrub($redir) if !$safe;
442            push @{$metaheaders{$page}}, $redir;
443         
444            return "Redirecting to $value ...";
445         }
446         
447         
448         # Feed this routine a string containing <nowiki>...</nowiki> sections,
449         # this routine calls your callback for every section not within nowikis,
450         # collecting its return values and returning the rewritten string.
451         sub skip_nowiki
452         {
453            my $content = shift;
454            my $proc = shift;
455         
456            my $result = "";
457            my $state = 0;
458         
459            for(split(/(<nowiki[^>]*>.*?<\/nowiki\s*>)/s, $content)) {
460               $result .= ($state ? $_ : &$proc($_));
461               $state = !$state;
462            }
463         
464            return $result;
465         }
466         
467         
468         # Converts all links in the page, wiki and otherwise.
469         sub linkify (@)
470         {
471            my %params=@_;
472         
473            my $page=$params{page};
474            my $destpage=$params{destpage};
475            my $content=$params{content};
476         
477            my $file=$pagesources{$page};
478            my $type=pagetype($file);
479            my $counter = 1;
480         
481            if($type ne 'mediawiki') {
482               return IkiWiki::Plugin::link::linkify(@_);
483            }
484         
485            my $redir = check_redirect(%params);
486            return $redir if defined $redir;
487         
488            # this code was copied from MediawikiFormat.pm.
489            # Heavily changed because MF.pm screws up escaping when it does
490            # this awful hack: $uricCheat =~ tr/://d;
491            my $schemas = [qw(http https ftp mailto gopher)];
492            my $re = join "|", map {qr/\Q$_\E/} @$schemas;
493            my $schemes = qr/(?:$re)/;
494            # And this is copied from URI:
495            my $reserved   = q(;/?@&=+$,);   # NOTE: no colon or [] !
496            my $uric       = quotemeta($reserved) . $URI::unreserved . "%#";
497         
498            my $result = skip_nowiki($content, sub {
499               $_ = shift;
500         
501               # Escape any anchors
502               #s/<(a[\s>\/])/&lt;$1/ig;
503               # Disabled because this appears to screw up the aggregate plugin.
504               # I guess we'll rely on Iki to post-sanitize this sort of stuff.
505         
506               # Replace external links, http://blah or [http://blah]
507               s{\b($schemes:[$uric][:$uric]+)|\[($schemes:[$uric][:$uric]+)([^\]]*?)\]}{
508                  generate_external_link($1||$2, $3, \$counter)
509               }eg;
510         
511               # Handle links that only contain fragments.
512               s{ \[\[ \s* (\#[^|\]'"<>&;]+) (?:\| ([^\]'"<>&;]*))? \]\] }{
513                  generate_fragment_link($1, $2)
514               }xeg;
515         
516               # Match all internal links
517               s{$link_regexp}{
518                  generate_internal_link($page, $1, $2, $3, $4, sub {
519                     my($linkpage, $linktext, $anchor) = @_;
520                     return htmllink($page, $destpage, $linkpage,
521                        linktext => $linktext,
522                        anchor => underscorize(scrunch($anchor)));
523                  });
524               }eg;
525            
526               return $_;
527            });
528         
529            return $result;
530         }
531         
532         
533         # Find all WikiLinks in the page.
534         sub scan (@)
535         {
536            my %params = @_;
537            my $page=$params{page};
538            my $content=$params{content};
539         
540            my $file=$pagesources{$page};
541            my $type=pagetype($file);
542         
543            if($type ne 'mediawiki') {
544               return IkiWiki::Plugin::link::scan(@_);
545            }
546         
547            skip_nowiki($content, sub {
548               $_ = shift;
549               while(/$link_regexp/g) {
550                  generate_internal_link($page, $1, '', '', '', sub {
551                     my($linkpage, $linktext, $anchor) = @_;
552                     push @{$links{$page}}, $linkpage;
553                     return undef;
554                  });
555               }
556               return '';
557            });
558         }
559         
560         
561         # Convert the page to HTML.
562         sub htmlize (@)
563         {
564            my %params=@_;
565            my $page = $params{page};
566            my $content = $params{content};
567         
568         
569            return $content if $markup_disabled;
570         
571            # Do a little preprocessing to babysit Text::MediawikiFormat
572            # If a line begins with tabs, T:MwF won't convert it into preformatted blocks.
573            $content =~ s/^\t/    /mg;
574         
575            my $ret = Text::MediawikiFormat::format($content, {
576         
577                allowed_tags    => [#HTML
578                         # MediawikiFormat default
579                         qw(b big blockquote br caption center cite code dd
580                            div dl dt em font h1 h2 h3 h4 h5 h6 hr i li ol p
581                            pre rb rp rt ruby s samp small strike strong sub
582                            sup table td th tr tt u ul var),
583                          # Mediawiki Specific
584                          qw(nowiki),
585                          # Our additions
586                          qw(del ins),   # These should have been added all along.
587                          qw(span),   # Mediawiki allows span but that's rather scary...?
588                          qw(a),      # this is unfortunate; should handle links after rendering the page.
589                        ],
590         
591                allowed_attrs   => [
592                         qw(title align lang dir width height bgcolor),
593                         qw(clear), # BR
594                         qw(noshade), # HR
595                         qw(cite), # BLOCKQUOTE, Q
596                         qw(size face color), # FONT
597                         # For various lists, mostly deprecated but safe
598                         qw(type start value compact),
599                         # Tables
600                         qw(summary width border frame rules cellspacing
601                            cellpadding valign char charoff colgroup col
602                            span abbr axis headers scope rowspan colspan),
603                         qw(id class name style), # For CSS
604                         # Our additions
605                         qw(href),
606                        ],
607         
608               }, {
609               extended => 0,
610               absolute_links => 0,
611               implicit_links => 0
612               });
613         
614            return $ret;
615         }
616         
617         
618         # This is only needed to support the check_redirect call.
619         sub pagetemplate (@)
620         {
621            my %params = @_;
622            my $page = $params{page};
623            my $destpage = $params{destpage};
624            my $template = $params{template};
625         
626            # handle metaheaders for redirects
627            if (exists $metaheaders{$page} && $template->query(name => "meta")) {
628            # avoid duplicate meta lines
629               my %seen;
630               $template->param(meta => join("\n", grep { (! $seen{$_}) && ($seen{$_}=1) } @{$metaheaders{$page}}));
631            }
632         
633            $template->param(tags => [
634               map {
635                  link => htmllink($page, $destpage, tagpage($_), rel => "tag")
636               }, sort keys %{$tags{$page}}
637            ]) if exists $tags{$page} && %{$tags{$page}} && $template->query(name => "tags");
638         
639            # It's an rss/atom template. Add any categories.
640            if ($template->query(name => "categories")) {
641               if (exists $tags{$page} && %{$tags{$page}}) {
642                  $template->param(categories => [map { category => $_ },
643                     sort keys %{$tags{$page}}]);
644               }
645            }
646         }
647         
648         1
649
650 ----
651
652 Hello. Got ikiwiki running and I'm planning to convert my personal
653 Mediawiki wiki to ikiwiki so I can take offline copies around. If anyone
654 has an old copy of the instructions, or any advice on where to start I'd be
655 glad to hear it. Otherwise I'm just going to chronicle my journey on the
656 page.--[[users/Chadius]]
657
658 > Today I saw that someone is working to import wikipedia into git.
659 > <http://www.gossamer-threads.com/lists/wiki/foundation/181163>
660 > Since wikipedia uses mediawiki, perhaps his importer will work
661 > on mediawiki in general. It seems to produce output that could be
662 > used by the [[plugins/contrib/mediawiki]] plugin, if the filenames
663 > were fixed to use the right extension.  --[[Joey]] 
664
665 >> Here's another I found while browsing around starting from the link you gave Joey<br />
666 >> <http://github.com/scy/levitation><br />
667 >> As I don't run mediawiki anymore, but I still have my xz/gzip-compressed XML dumps,
668 >> it's certainly easier for me to do it this way; also a file or a set of files is easier to lug
669 >> around on some medium than a full mysqld or postgres master and relevant databases.