]> git.madduck.net Git - code/myrepos.git/blob - mr

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

642aa6f6c09d0f0057b98b6e109e398d7a97700f
[code/myrepos.git] / mr
1 #!/usr/bin/perl
2
3 =head1 NAME
4
5 mr - a Multiple Repository management tool
6
7 =head1 SYNOPSIS
8
9 B<mr> [options] checkout
10
11 B<mr> [options] update
12
13 B<mr> [options] status
14
15 B<mr> [options] commit [-m "message"]
16
17 B<mr> [options] record [-m "message"]
18
19 B<mr> [options] push
20
21 B<mr> [options] diff
22
23 B<mr> [options] log
24
25 B<mr> [options] bootstrap url [directory]
26
27 B<mr> [options] register [repository]
28
29 B<mr> [options] config section ["parameter=[value]" ...]
30
31 B<mr> [options] action [params ...]
32
33 B<mr> [options] [online|offline]
34
35 B<mr> [options] remember action [params ...]
36
37 =head1 DESCRIPTION
38
39 B<mr> is a Multiple Repository management tool. It can checkout, update, or
40 perform other actions on a set of repositories as if they were one combined
41 repository. It supports any combination of subversion, git, cvs, mercurial,
42 bzr, darcs and fossil repositories, and support for other revision
43 control systems can easily be added.
44
45 B<mr> cds into and operates on all registered repositories at or below your
46 working directory. Or, if you are in a subdirectory of a repository that
47 contains no other registered repositories, it will stay in that directory,
48 and work on only that repository,
49
50 B<mr> is configured by .mrconfig files, which list the repositories. It
51 starts by reading the .mrconfig file in your home directory, and this can
52 in turn chain load .mrconfig files from repositories.
53
54 These predefined commands should be fairly familiar to users of any revision
55 control system:
56
57 =over 4
58
59 =item checkout (or co)
60
61 Checks out any repositories that are not already checked out.
62
63 =item update
64
65 Updates each repository from its configured remote repository.
66
67 If a repository isn't checked out yet, it will first check it out.
68
69 =item status
70
71 Displays a status report for each repository, showing what
72 uncommitted changes are present in the repository.
73
74 =item commit (or ci)
75
76 Commits changes to each repository. (By default, changes are pushed to the
77 remote repository too, when using distributed systems like git. If you
78 don't like this default, you can change it in your .mrconfig, or use record
79 instead.)
80
81 The optional -m parameter allows specifying a commit message.
82
83 =item record
84
85 Records changes to the local repository, but does not push them to the
86 remote repository. Only supported for distributed revision control systems.
87
88 The optional -m parameter allows specifying a commit message.
89
90 =item push
91
92 Pushes committed local changes to the remote repository. A no-op for
93 centralized revision control systems.
94
95 =item diff
96
97 Show a diff of uncommitted changes.
98
99 =item log
100
101 Show the commit log.
102
103 =back
104
105 These commands are also available:
106
107 =over 4
108
109 =item bootstrap url [directory]
110
111 Causes mr to download the url, and use it as a .mrconfig file
112 to checkout the repositories listed in it, into the specified directory.
113
114 The directory will be created if it does not exist. If no directory is
115 specified, the current directory will be used.
116
117 If the .mrconfig file includes a repository named ".", that
118 is checked out into the top of the specified directory.
119
120 =item list (or ls)
121
122 List the repositories that mr will act on.
123
124 =item register
125
126 Register an existing repository in a mrconfig file. By default, the
127 repository in the current directory is registered, or you can specify a
128 directory to register.
129
130 The mrconfig file that is modified is chosen by either the -c option, or by
131 looking for the closest known one at or below the current directory.
132
133 =item config
134
135 Adds, modifies, removes, or prints a value from a mrconfig file. The next
136 parameter is the name of the section the value is in. To add or modify
137 values, use one or more instances of "parameter=value". Use "parameter=" to
138 remove a parameter. Use just "parameter" to get the value of a parameter.
139
140 For example, to add (or edit) a repository in src/foo:
141
142   mr config src/foo checkout="svn co svn://example.com/foo/trunk foo"
143
144 To show the command that mr uses to update the repository in src/foo:
145
146   mr config src/foo update
147
148 To see the built-in library of shell functions contained in mr:
149
150   mr config DEFAULT lib
151
152 The ~/.mrconfig file is used by default. To use a different config file,
153 use the -c option.
154
155 =item offline
156
157 Advises mr that it is in offline mode. Any commands that fail in
158 offline mode will be remembered, and retried when mr is told it's online.
159
160 =item online
161
162 Advices mr that it is in online mode again. Commands that failed while in
163 offline mode will be re-run.
164
165 =item remember
166
167 Remember a command, to be run later when mr re-enters online mode. This
168 implicitly puts mr into offline mode. The command can be any regular mr
169 command. This is useful when you know that a command will fail due to being
170 offline, and so don't want to run it right now at all, but just remember
171 to run it when you go back online.
172
173 =item help
174
175 Displays this help.
176
177 =back
178
179 Actions can be abbreviated to any unambiguous substring, so
180 "mr st" is equivalent to "mr status", and "mr up" is equivalent to "mr
181 update"
182
183 Additional parameters can be passed to most commands, and are passed on
184 unchanged to the underlying revision control system. This is mostly useful
185 if the repositories mr will act on all use the same revision control
186 system.
187
188 =head1 OPTIONS
189
190 =over 4
191
192 =item -d directory
193
194 =item --directory directory
195
196 Specifies the topmost directory that B<mr> should work in. The default is
197 the current working directory.
198
199 =item -c mrconfig
200
201 =item --config mrconfig
202
203 Use the specified mrconfig file. The default is B<~/.mrconfig>
204
205 =item -p
206
207 =item --path
208
209 Search in the current directory, and its parent directories and use
210 the first B<.mrconfig> found, instead of the default B<~/.mrconfig>.
211
212 =item -v
213
214 =item --verbose
215
216 Be verbose.
217
218 =item -q
219
220 =item --quiet
221
222 Be quiet.
223
224 =item -k
225
226 =item --insecure
227
228 Accept untrusted SSL certificates when bootstrapping.
229
230 =item -s
231
232 =item --stats
233
234 Expand the statistics line displayed at the end to include information
235 about exactly which repositories failed and were skipped, if any.
236
237 =item -i
238
239 =item --interactive
240
241 Interactive mode. If a repository fails to be processed, a subshell will be
242 started which you can use to resolve or investigate the problem. Exit the
243 subshell to continue the mr run.
244
245 =item -n [number]
246
247 =item --no-recurse [number]
248
249 If no number if specified, just operate on the repository for the current
250 directory, do not recurse into deeper repositories.
251
252 If a number is specified, will recurse into repositories at most that many
253 subdirectories deep. For example, with -n 2 it would recurse into ./src/foo,
254 but not ./src/packages/bar.
255
256 =item -j [number]
257
258 =item --jobs [number]
259
260 Run the specified number of jobs in parallel, or an unlimited number of jobs
261 with no number specified. This can greatly speed up operations such as updates.
262 It is not recommended for interactive operations.
263
264 Note that running more than 10 jobs at a time is likely to run afoul of
265 ssh connection limits. Running between 3 and 5 jobs at a time will yield
266 a good speedup in updates without loading the machine too much.
267
268 =item -t
269
270 =item --trust-all
271
272 Trust all mrconfig files even if they are not listed in ~/.mrtrust.
273 Use with caution.
274
275 =back
276
277 =head1 MRCONFIG FILES
278
279 Here is an example .mrconfig file:
280
281   [src]
282   checkout = svn co svn://svn.example.com/src/trunk src
283   chain = true
284
285   [src/linux-2.6]
286   checkout = git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git &&
287         cd linux-2.6 &&
288         git checkout -b mybranch origin/master
289
290 The .mrconfig file uses a variant of the INI file format. Lines starting with
291 "#" are comments. Values can be continued to the following line by
292 indenting the line with whitespace.
293
294 The "DEFAULT" section allows setting default values for the sections that
295 come after it.
296
297 The "ALIAS" section allows adding aliases for actions. Each parameter
298 is an alias, and its value is the action to use.
299
300 All other sections add repositories. The section header specifies the
301 directory where the repository is located. This is relative to the directory
302 that contains the mrconfig file, but you can also choose to use absolute
303 paths. (Note that you can use environment variables in section names; they
304 will be passed through the shell for expansion. For example, 
305 "[$HOSTNAME]", or "[${HOSTNAME}foo]")
306
307 Within a section, each parameter defines a shell command to run to handle a
308 given action. mr contains default handlers for "update", "status",
309 "commit", and other standard actions. Normally you only need to specify what
310 to do for "checkout".
311
312 Note that these shell commands are run in a "set -e" shell
313 environment, where any additional parameters you pass are available in
314 "$@". The "checkout" command is run in the parent of the repository
315 directory, since the repository isn't checked out yet. All other commands
316 are run inside the repository, though not necessarily at the top of it.
317
318 The "MR_REPO" environment variable is set to the path to the top of the
319 repository. (For the "register" action, "MR_REPO" is instead set to the 
320 basename of the directory that should be created when checking the
321 repository out.)
322
323 The "MR_CONFIG" environment variable is set to the .mrconfig file
324 that defines the repo being acted on, or, if the repo is not yet in a config
325 file, the .mrconfig file that should be modified to register the repo.
326
327 A few parameters have special meanings:
328
329 =over 4
330
331 =item skip
332
333 If the "skip" parameter is set and its command returns true, then B<mr>
334 will skip acting on that repository. The command is passed the action
335 name in $1.
336
337 Here are two examples. The first skips the repo unless
338 mr is run by joey. The second uses the hours_since function
339 (included in mr's built-in library) to skip updating the repo unless it's
340 been at least 12 hours since the last update.
341
342   skip = test `whoami` != joey
343   skip = [ "$1" = update ] && ! hours_since "$1" 12
344
345 =item order
346
347 The "order" parameter can be used to override the default ordering of
348 repositories. The default order value is 10. Use smaller values to make
349 repositories be processed earlier, and larger values to make repositories
350 be processed later.
351
352 Note that if a repository is located in a subdirectory of another
353 repository, ordering it to be processed earlier is not recommended.
354
355 =item chain
356
357 If the "chain" parameter is set and its command returns true, then B<mr>
358 will try to load a .mrconfig file from the root of the repository.
359
360 =item include
361
362 If the "include" parameter is set, its command is ran, and should output
363 additional mrconfig file content. The content is included as if it were
364 part of the including file.
365
366 Unlike all other parameters, this parameter does not need to be placed
367 within a section.
368
369 =item lib
370
371 The "lib" parameter can specify some shell code that will be run before each
372 command, this can be a useful way to define shell functions for other commands
373 to use.
374
375 =item fixups
376
377 If the "fixups" parameter is set, its command is run whenever a repository
378 is checked out, or updated. This provides an easy way to do things
379 like permissions fixups, or other tweaks to the repository content,
380 whenever the repository is changed.
381
382 =item pre_ and post_
383
384 If a "pre_action" parameter is set, its command is run before mr performs the
385 specified action. Similarly, "post_action" parameters are run after mr
386 successfully performs the specified action. For example, "pre_commit" is
387 run before committing; "post_update" is run after updating.
388
389 =back
390
391 When looking for a command to run for a given action, mr first looks for
392 a parameter with the same name as the action. If that is not found, it
393 looks for a parameter named "rcs_action" (substituting in the name of the
394 revision control system and the action). The name of the revision control
395 system is itself determined by running each defined "rcs_test" action,
396 until one succeeds.
397
398 Internally, mr has settings for "git_update", "svn_update", etc. To change
399 the action that is performed for a given revision control system, you can
400 override these rcs specific actions. To add a new revision control system,
401 you can just add rcs specific actions for it.
402
403 The ~/.mrlog file contains commands that mr has remembered to run later,
404 due to being offline. You can delete or edit this file to remove commands,
405 or even to add other commands for 'mr online' to run. If the file is
406 present, mr assumes it is in offline mode.
407
408 =head1 UNTRUSTED MRCONFIG FILES
409
410 Since mrconfig files can contain arbitrary shell commands, they can do
411 anything. This flexibility is good, but it also allows a malicious mrconfig
412 file to delete your whole home directory. Such a file might be contained
413 inside a repository that your main ~/.mrconfig checks out and chains to. To
414 avoid worries about evil commands in a mrconfig file, mr
415 has the ability to read mrconfig files in untrusted mode. Such files are
416 limited to running only known safe commands (like "git clone") in a
417 carefully checked manner.
418
419 By default, mr trusts all mrconfig files. (This default will change in a
420 future release!) But if you have a ~/.mrtrust file, mr will only trust
421 mrconfig files that are listed within it. (One file per line.) All other
422 files will be treated as untrusted.
423
424 =head1 EXTENSIONS
425
426 mr can be extended to support things such as unison and git-svn. Some
427 files providing such extensions are available in /usr/share/mr/. See
428 the documentation in the files for details about using them.
429
430 =head1 AUTHOR
431
432 Copyright 2007-2010 Joey Hess <joey@kitenet.net>
433
434 Licensed under the GNU GPL version 2 or higher.
435
436 http://kitenet.net/~joey/code/mr/
437
438 =cut
439
440 use warnings;
441 use strict;
442 use Getopt::Long;
443 use Cwd qw(getcwd abs_path);
444
445 # things that can happen when mr runs a command
446 use constant {
447         OK => 0,
448         FAILED => 1,
449         SKIPPED => 2,
450         ABORT => 3,
451 };
452
453 # configurables
454 my $config_overridden=0;
455 my $verbose=0;
456 my $quiet=0;
457 my $stats=0;
458 my $insecure=0;
459 my $interactive=0;
460 my $max_depth;
461 my $no_chdir=0;
462 my $jobs=1;
463 my $trust_all=0;
464 my $directory=getcwd();
465 $ENV{MR_CONFIG}="$ENV{HOME}/.mrconfig";
466
467 # globals :-(
468 my %config;
469 my %configfiles;
470 my %knownactions;
471 my %alias;
472 my (@ok, @failed, @skipped);
473
474 main();
475
476 my %rcs;
477 sub rcs_test {
478         my ($action, $dir, $topdir, $subdir) = @_;
479
480         if (exists $rcs{$dir}) {
481                 return $rcs{$dir};
482         }
483
484         my $test="set -e\n";
485         foreach my $rcs_test (
486                         sort {
487                                 length $a <=> length $b 
488                                           ||
489                                        $a cmp $b
490                         } grep { /_test$/ } keys %{$config{$topdir}{$subdir}}) {
491                 my ($rcs)=$rcs_test=~/(.*)_test/;
492                 $test="my_$rcs_test() {\n$config{$topdir}{$subdir}{$rcs_test}\n}\n".$test;
493                 $test.="if my_$rcs_test; then echo $rcs; fi\n";
494         }
495         $test=$config{$topdir}{$subdir}{lib}."\n".$test
496                 if exists $config{$topdir}{$subdir}{lib};
497         
498         print "mr $action: running rcs test >>$test<<\n" if $verbose;
499         my $rcs=`$test`;
500         chomp $rcs;
501         if ($rcs=~/\n/s) {
502                 $rcs=~s/\n/, /g;
503                 print STDERR "mr $action: found multiple possible repository types ($rcs) for ".fulldir($topdir, $subdir)."\n";
504                 return undef;
505         }
506         if (! length $rcs) {
507                 return $rcs{$dir}=undef;
508         }
509         else {
510                 return $rcs{$dir}=$rcs;
511         }
512 }
513         
514 sub findcommand {
515         my ($action, $dir, $topdir, $subdir, $is_checkout) = @_;
516         
517         if (exists $config{$topdir}{$subdir}{$action}) {
518                 return $config{$topdir}{$subdir}{$action};
519         }
520
521         if ($is_checkout) {
522                 return undef;
523         }
524
525         my $rcs=rcs_test(@_);
526
527         if (defined $rcs && 
528             exists $config{$topdir}{$subdir}{$rcs."_".$action}) {
529                 return $config{$topdir}{$subdir}{$rcs."_".$action};
530         }
531         else {
532                 return undef;
533         }
534 }
535
536 sub fulldir {
537         my ($topdir, $subdir) = @_;
538         return $subdir =~ /^\// ? $subdir : $topdir.$subdir;
539 }
540
541 sub action {
542         my ($action, $dir, $topdir, $subdir, $force_checkout) = @_;
543         my $fulldir=fulldir($topdir, $subdir);
544
545         $ENV{MR_CONFIG}=$configfiles{$topdir};
546         my $lib=exists $config{$topdir}{$subdir}{lib} ?
547                        $config{$topdir}{$subdir}{lib}."\n" : "";
548         my $is_checkout=($action eq 'checkout');
549         my $is_update=($action =~ /update/);
550
551         $ENV{MR_REPO}=$dir;
552
553         if ($is_checkout) {
554                 if (! $force_checkout) {
555                         if (-d $dir) {
556                                 print "mr $action: $dir already exists, skipping checkout\n" if $verbose;
557                                 return SKIPPED;
558                         }
559         
560                         $dir=~s/^(.*)\/[^\/]+\/?$/$1/;
561                 }
562         }
563         elsif ($is_update) {
564                 if (! -d $dir) {
565                         return action("checkout", $dir, $topdir, $subdir);
566                 }
567         }
568
569         my $skiptest=findcommand("skip", $dir, $topdir, $subdir, $is_checkout);
570         my $command=findcommand($action, $dir, $topdir, $subdir, $is_checkout);
571
572         if (defined $skiptest) {
573                 my $test="set -e;".$lib.
574                         "my_action(){ $skiptest\n }; my_action '$action'";
575                 print "mr $action: running skip test >>$test<<\n" if $verbose;
576                 my $ret=system($test);
577                 if ($ret != 0) {
578                         if (($? & 127) == 2) {
579                                 print STDERR "mr $action: interrupted\n";
580                                 return ABORT;
581                         }
582                         elsif ($? & 127) {
583                                 print STDERR "mr $action: skip test received signal ".($? & 127)."\n";
584                                 return ABORT;
585                         }
586                 }
587                 if ($ret >> 8 == 0) {
588                         print "mr $action: $dir skipped per config file\n" if $verbose;
589                         return SKIPPED;
590                 }
591         }
592
593         if ($is_checkout && ! -d $dir) {
594                 print "mr $action: creating parent directory $dir\n" if $verbose;
595                 system("mkdir", "-p", $dir);
596         }
597
598         if (! $no_chdir && ! chdir($dir)) {
599                 print STDERR "mr $action: failed to chdir to $dir: $!\n";
600                 return FAILED;
601         }
602         elsif (! defined $command) {
603                 my $rcs=rcs_test(@_);
604                 if (! defined $rcs) {
605                         print STDERR "mr $action: unknown repository type and no defined $action command for $fulldir\n";
606                         return FAILED;
607                 }
608                 else {
609                         print STDERR "mr $action: no defined action for $rcs repository $fulldir, skipping\n";
610                         return SKIPPED;
611                 }
612         }
613         else {
614                 if (! $no_chdir) {
615                         print "mr $action: $fulldir\n" unless $quiet;
616                 }
617                 else {
618                         my $s=$directory;
619                         $s=~s/^\Q$fulldir\E\/?//;
620                         print "mr $action: $fulldir (in subdir $s)\n" unless $quiet;
621                 }
622
623                 my $hookret=hook("pre_$action", $topdir, $subdir);
624                 return $hookret if $hookret != OK;
625
626                 $command="set -e; ".$lib.
627                         "my_action(){ $command\n }; my_action ".
628                         join(" ", map { s/\//\/\//g; s/"/\"/g; '"'.$_.'"' } @ARGV);
629                 print "mr $action: running >>$command<<\n" if $verbose;
630                 my $ret=system($command);
631                 if ($ret != 0) {
632                         if (($? & 127) == 2) {
633                                 print STDERR "mr $action: interrupted\n";
634                                 return ABORT;
635                         }
636                         elsif ($? & 127) {
637                                 print STDERR "mr $action: received signal ".($? & 127)."\n";
638                                 return ABORT;
639                         }
640                         print STDERR "mr $action: failed ($ret)\n" if $verbose;
641                         if ($ret >> 8 != 0) {
642                                 print STDERR "mr $action: command failed\n";
643                                 if (-e "$ENV{HOME}/.mrlog" && $action ne 'remember') {
644                                         # recreate original command line to
645                                         # remember, and avoid recursing
646                                         my @orig=@ARGV;
647                                         @ARGV=('-n', $action, @orig);
648                                         action("remember", $dir, $topdir, $subdir);
649                                         @ARGV=@orig;
650                                 }
651                         }
652                         elsif ($ret != 0) {
653                                 print STDERR "mr $action: command died ($ret)\n";
654                         }
655                         return FAILED;
656                 }
657                 else {
658                         if ($is_checkout && ! -d $dir) {
659                                 print STDERR "mr $action: $dir missing after checkout\n";;
660                                 return FAILED;
661                         }
662
663                         my $ret=hook("post_$action", $topdir, $subdir);
664                         return $ret if $ret != OK;
665                         
666                         if (($is_checkout || $is_update)) {
667                                 my $ret=hook("fixups", $topdir, $subdir);
668                                 return $ret if $ret != OK;
669                         }
670                         
671                         return OK;
672                 }
673         }
674 }
675
676 sub hook {
677         my ($hook, $topdir, $subdir) = @_;
678
679         my $command=$config{$topdir}{$subdir}{$hook};
680         return OK unless defined $command;
681         my $lib=exists $config{$topdir}{$subdir}{lib} ?
682                        $config{$topdir}{$subdir}{lib}."\n" : "";
683         my $shell="set -e;".$lib.
684                 "my_hook(){ $command\n }; my_hook";
685         print "mr $hook: running >>$shell<<\n" if $verbose;
686         my $ret=system($shell);
687         if ($ret != 0) {
688                 if (($? & 127) == 2) {
689                         print STDERR "mr $hook: interrupted\n";
690                         return ABORT;
691                 }
692                 elsif ($? & 127) {
693                         print STDERR "mr $hook: received signal ".($? & 127)."\n";
694                         return ABORT;
695                 }
696         }
697
698         return OK;
699 }
700
701 # run actions on multiple repos, in parallel
702 sub mrs {
703         my $action=shift;
704         my @repos=@_;
705
706         $| = 1;
707         my @active;
708         my @fhs;
709         my @out;
710         my $running=0;
711         while (@fhs or @repos) {
712                 while ((!$jobs || $running < $jobs) && @repos) {
713                         $running++;
714                         my $repo = shift @repos;
715                         pipe(my $outfh, CHILD_STDOUT);
716                         pipe(my $errfh, CHILD_STDERR);
717                         my $pid;
718                         unless ($pid = fork) {
719                                 die "mr $action: cannot fork: $!" unless defined $pid;
720                                 open(STDOUT, ">&CHILD_STDOUT") || die "mr $action cannot reopen stdout: $!";
721                                 open(STDERR, ">&CHILD_STDERR") || die "mr $action cannot reopen stderr: $!";
722                                 close CHILD_STDOUT;
723                                 close CHILD_STDERR;
724                                 close $outfh;
725                                 close $errfh;
726                                 exit action($action, @$repo);
727                         }
728                         close CHILD_STDOUT;
729                         close CHILD_STDERR;
730                         push @active, [$pid, $repo];
731                         push @fhs, [$outfh, $errfh];
732                         push @out, ['',     ''];
733                 }
734                 my ($rin, $rout) = ('','');
735                 my $nfound;
736                 foreach my $fh (@fhs) {
737                         next unless defined $fh;
738                         vec($rin, fileno($fh->[0]), 1) = 1 if defined $fh->[0];
739                         vec($rin, fileno($fh->[1]), 1) = 1 if defined $fh->[1];
740                 }
741                 $nfound = select($rout=$rin, undef, undef, 1);
742                 foreach my $channel (0, 1) {
743                         foreach my $i (0..$#fhs) {
744                                 next unless defined $fhs[$i];
745                                 my $fh = $fhs[$i][$channel];
746                                 next unless defined $fh;
747                                 if (vec($rout, fileno($fh), 1) == 1) {
748                                         my $r = '';
749                                         if (sysread($fh, $r, 1024) == 0) {
750                                                 close($fh);
751                                                 $fhs[$i][$channel] = undef;
752                                                 if (! defined $fhs[$i][0] &&
753                                                     ! defined $fhs[$i][1]) {
754                                                         waitpid($active[$i][0], 0);
755                                                         print STDOUT $out[$i][0];
756                                                         print STDERR $out[$i][1];
757                                                         record($active[$i][1], $? >> 8);
758                                                         splice(@fhs, $i, 1);
759                                                         splice(@active, $i, 1);
760                                                         splice(@out, $i, 1);
761                                                         $running--;
762                                                 }
763                                         }
764                                         $out[$i][$channel] .= $r;
765                                 }
766                         }
767                 }
768         }
769 }
770
771 sub record {
772         my $dir=shift()->[0];
773         my $ret=shift;
774
775         if ($ret == OK) {
776                 push @ok, $dir;
777                 print "\n" unless $quiet;
778         }
779         elsif ($ret == FAILED) {
780                 if ($interactive) {
781                         chdir($dir) unless $no_chdir;
782                         print STDERR "mr: Starting interactive shell. Exit shell to continue.\n";
783                         system((getpwuid($<))[8], "-i");
784                 }
785                 push @failed, $dir;
786                 print "\n" unless $quiet;
787         }
788         elsif ($ret == SKIPPED) {
789                 push @skipped, $dir;
790         }
791         elsif ($ret == ABORT) {
792                 exit 1;
793         }
794         else {
795                 die "unknown exit status $ret";
796         }
797 }
798
799 sub showstats {
800         my $action=shift;
801         if (! @ok && ! @failed && ! @skipped) {
802                 die "mr $action: no repositories found to work on\n";
803         }
804         print "mr $action: finished (".join("; ",
805                 showstat($#ok+1, "ok", "ok"),
806                 showstat($#failed+1, "failed", "failed"),
807                 showstat($#skipped+1, "skipped", "skipped"),
808         ).")\n" unless $quiet;
809         if ($stats) {
810                 if (@skipped) {
811                         print "mr $action: (skipped: ".join(" ", @skipped).")\n" unless $quiet;
812                 }
813                 if (@failed) {
814                         print STDERR "mr $action: (failed: ".join(" ", @failed).")\n";
815                 }
816         }
817 }
818
819 sub showstat {
820         my $count=shift;
821         my $singular=shift;
822         my $plural=shift;
823         if ($count) {
824                 return "$count ".($count > 1 ? $plural : $singular);
825         }
826         return;
827 }
828
829 # an ordered list of repos
830 sub repolist {
831         my @list;
832         foreach my $topdir (sort keys %config) {
833                 foreach my $subdir (sort keys %{$config{$topdir}}) {
834                         push @list, {
835                                 topdir => $topdir,
836                                 subdir => $subdir,
837                                 order => $config{$topdir}{$subdir}{order},
838                         };
839                 }
840         }
841         return sort {
842                 $a->{order}  <=> $b->{order}
843                              ||
844                 $a->{topdir} cmp $b->{topdir}
845                              ||
846                 $a->{subdir} cmp $b->{subdir}
847         } @list;
848 }
849
850 sub repodir {
851         my $repo=shift;
852         my $topdir=$repo->{topdir};
853         my $subdir=$repo->{subdir};
854         my $ret=($subdir =~/^\//) ? $subdir : $topdir.$subdir;
855         $ret=~s/\/\.$//;
856         return $ret;
857 }
858
859 # figure out which repos to act on
860 sub selectrepos {
861         my @repos;
862         foreach my $repo (repolist()) {
863                 my $topdir=$repo->{topdir};
864                 my $subdir=$repo->{subdir};
865
866                 next if $subdir eq 'DEFAULT';
867                 my $dir=repodir($repo);
868                 my $d=$directory;
869                 $dir.="/" unless $dir=~/\/$/;
870                 $d.="/" unless $d=~/\/$/;
871                 next if $dir ne $d && $dir !~ /^\Q$d\E/;
872                 if (defined $max_depth) {
873                         my @a=split('/', $dir);
874                         my @b=split('/', $d);
875                         do { } while (@a && @b && shift(@a) eq shift(@b));
876                         next if @a > $max_depth || @b > $max_depth;
877                 }
878                 push @repos, [$dir, $topdir, $subdir];
879         }
880         if (! @repos) {
881                 # fallback to find a leaf repo
882                 foreach my $repo (reverse repolist()) {
883                         my $topdir=$repo->{topdir};
884                         my $subdir=$repo->{subdir};
885                         
886                         next if $subdir eq 'DEFAULT';
887                         my $dir=repodir($repo);
888                         my $d=$directory;
889                         $dir.="/" unless $dir=~/\/$/;
890                         $d.="/" unless $d=~/\/$/;
891                         if ($d=~/^\Q$dir\E/) {
892                                 push @repos, [$dir, $topdir, $subdir];
893                                 last;
894                         }
895                 }
896                 $no_chdir=1;
897         }
898         return @repos;
899 }
900
901 sub expandenv {
902         my $val=shift;
903         
904
905         if ($val=~/\$/) {
906                 $val=`echo "$val"`;
907                 chomp $val;
908         }
909         
910         return $val;
911 }
912
913 my %trusted;
914 sub is_trusted_config {
915         my $config=shift; # must be abs_pathed already
916
917         # We always trust ~/.mrconfig.
918         return 1 if $config eq abs_path("$ENV{HOME}/.mrconfig");
919
920         return 1 if $trust_all;
921
922         my $trustfile=$ENV{HOME}."/.mrtrust";
923
924         if (! -e $trustfile) {
925                 print "mr: Assuming $config is trusted.\n";
926                 print "mr: For better security, you are encouraged to create ~/.mrtrust\n";
927                 print "mr: and list all trusted mrconfig files in it.\n";
928                 return 1;
929         }
930
931         if (! %trusted) {
932                 $trusted{"$ENV{HOME}/.mrconfig"}=1;
933                 open (TRUST, "<", $trustfile) || die "$trustfile: $!";
934                 while (<TRUST>) {
935                         chomp;
936                         s/^~\//$ENV{HOME}\//;
937                         $trusted{abs_path($_)}=1;
938                 }
939                 close TRUST;
940         }
941
942         return $trusted{$config};
943 }
944
945
946 sub is_trusted_repo {
947         my $repo=shift;
948         
949         # Tightly limit what is allowed in a repo name.
950         # No ../, no absolute paths, and no unusual filenames
951         # that might try to escape to the shell.
952         return $repo =~ /^[-_.+\/A-Za-z0-9]+$/ &&
953                $repo !~ /\.\./ && $repo !~ /^\//;
954 }
955
956 sub is_trusted_checkout {
957         my $command=shift;
958         
959         # To determine if the command is safe, compare it with the
960         # *_trusted_checkout config settings. Those settings are
961         # templates for allowed commands, so make sure that each word
962         # of the command matches the corresponding word of the template.
963         
964         my @words;
965         foreach my $word (split(' ', $command)) {
966                 # strip quoting
967                 if ($word=~/^'(.*)'$/) {
968                         $word=$1;
969                 }
970                 elsif ($word=~/^"(.*)"$/) {
971                         $word=$1;
972                 }
973
974                 push @words, $word;
975         }
976
977         foreach my $key (grep { /_trusted_checkout$/ }
978                          keys %{$config{''}{DEFAULT}}) {
979                 my @twords=split(' ', $config{''}{DEFAULT}{$key});
980                 next if @words > @twords;
981
982                 my $match=1;
983                 my $url;
984                 for (my $c=0; $c < @twords && $match; $c++) {
985                         if ($twords[$c] eq '$url') {
986                                 # Match all the typical characters found in
987                                 # urls, plus @ which svn can use. Note
988                                 # that the "url" might also be a local
989                                 # directory.
990                                 $match=(
991                                         defined $words[$c] &&
992                                         $words[$c] =~ /^[-_.+:@\/A-Za-z0-9]+$/
993                                 );
994                                 $url=$words[$c];
995                         }
996                         elsif ($twords[$c] eq '$repo') {
997                                 # If a repo is not specified, assume it
998                                 # will be the last path component of the
999                                 # url, or something derived from it, and
1000                                 # check that.
1001                                 if (! defined $words[$c] && defined $url) {
1002                                         ($words[$c])=$url=~/\/([^\/]+)\/?$/;
1003                                 }
1004
1005                                 $match=(
1006                                         defined $words[$c] &&
1007                                         is_trusted_repo($words[$c])
1008                                 );
1009                         }
1010                         elsif (defined $words[$c] && $twords[$c] eq $words[$c]) {
1011                                 $match=1;
1012                         }
1013                         else {
1014                                 $match=0;
1015                         }
1016                 }
1017                 return 1 if $match;
1018         }
1019
1020         return 0;
1021 }
1022
1023 my %loaded;
1024 sub loadconfig {
1025         my $f=shift;
1026         my $dir=shift;
1027
1028         my @toload;
1029
1030         my $in;
1031         my $trusted;
1032         if (ref $f eq 'GLOB') {
1033                 $dir="";
1034                 $in=$f;
1035                 $trusted=1;
1036         }
1037         else {
1038                 if (! -e $f) {
1039                         return;
1040                 }
1041
1042                 my $absf=abs_path($f);
1043                 if ($loaded{$absf}) {
1044                         return;
1045                 }
1046                 $loaded{$absf}=1;
1047
1048                 $trusted=is_trusted_config($absf);
1049
1050                 if (! defined $dir) {
1051                         ($dir)=$f=~/^(.*\/)[^\/]+$/;
1052                         if (! defined $dir) {
1053                                 $dir=".";
1054                         }
1055                 }
1056
1057                 $dir=abs_path($dir)."/";
1058                 
1059                 if (! exists $configfiles{$dir}) {
1060                         $configfiles{$dir}=$f;
1061                 }
1062
1063                 # copy in defaults from first parent
1064                 my $parent=$dir;
1065                 while ($parent=~s/^(.*\/)[^\/]+\/?$/$1/) {
1066                         if ($parent eq '/') {
1067                                 $parent="";
1068                         }
1069                         if (exists $config{$parent} &&
1070                             exists $config{$parent}{DEFAULT}) {
1071                                 $config{$dir}{DEFAULT}={ %{$config{$parent}{DEFAULT}} };
1072                                 last;
1073                         }
1074                 }
1075                 
1076                 print "mr: loading config $f\n" if $verbose;
1077                 open($in, "<", $f) || die "mr: open $f: $!\n";
1078         }
1079         my @lines=<$in>;
1080         close $in unless ref $f eq 'GLOB';
1081
1082         my $section;
1083         my $line=0;
1084         while (@lines) {
1085                 $_=shift @lines;
1086                 $line++;
1087                 chomp;
1088                 next if /^\s*\#/ || /^\s*$/;
1089                 if (/^\[([^\]]*)\]\s*$/) {
1090                         $section=$1;
1091
1092                         if (! $trusted) {
1093                                 if (! is_trusted_repo($section) ||
1094                                     $section eq 'ALIAS' ||
1095                                     $section eq 'DEFAULT') {
1096                                         die "mr: illegal section \"[$section]\" in untrusted $f line $line\n";
1097                                 }
1098                         }
1099                         $section=expandenv($section) if $trusted;
1100                         if ($section ne 'ALIAS' &&
1101                             ! exists $config{$dir}{$section} &&
1102                             exists $config{$dir}{DEFAULT}) {
1103                                 # copy in defaults
1104                                 $config{$dir}{$section}={ %{$config{$dir}{DEFAULT}} };
1105                         }
1106                 }
1107                 elsif (/^(\w+)\s*=\s*(.*)/) {
1108                         my $parameter=$1;
1109                         my $value=$2;
1110
1111                         # continued value
1112                         while (@lines && $lines[0]=~/^\s(.+)/) {
1113                                 shift(@lines);
1114                                 $line++;
1115                                 $value.="\n$1";
1116                                 chomp $value;
1117                         }
1118
1119                         if (! $trusted) {
1120                                 # Untrusted files can only contain checkout
1121                                 # parameters.
1122                                 if ($parameter ne 'checkout') {
1123                                         die "mr: illegal setting \"$parameter=$value\" in untrusted $f line $line\n";
1124                                 }
1125                                 if (! is_trusted_checkout($value)) {
1126                                         die "mr: illegal checkout command \"$value\" in untrusted $f line $line\n";
1127                                 }
1128                         }
1129
1130                         if ($parameter eq "include") {
1131                                 print "mr: including output of \"$value\"\n" if $verbose;
1132                                 unshift @lines, `$value`;
1133                                 if ($?) {
1134                                         print STDERR "mr: include command exited nonzero ($?)\n";
1135                                 }
1136                                 next;
1137                         }
1138
1139                         if (! defined $section) {
1140                                 die "$f line $.: parameter ($parameter) not in section\n";
1141                         }
1142                         if ($section eq 'ALIAS') {
1143                                 $alias{$parameter}=$value;
1144                         }
1145                         elsif ($parameter eq 'lib') {
1146                                 $config{$dir}{$section}{lib}.=$value."\n";
1147                         }
1148                         else {
1149                                 $config{$dir}{$section}{$parameter}=$value;
1150                                 if ($parameter =~ /.*_(.*)/) {
1151                                         $knownactions{$1}=1;
1152                                 }
1153                                 else {
1154                                         $knownactions{$parameter}=1;
1155                                 }
1156                                 if ($parameter eq 'chain' &&
1157                                     length $dir && $section ne "DEFAULT" &&
1158                                     -e $dir.$section."/.mrconfig") {
1159                                         my $ret=system($value);
1160                                         if ($ret != 0) {
1161                                                 if (($? & 127) == 2) {
1162                                                         print STDERR "mr: chain test interrupted\n";
1163                                                         exit 2;
1164                                                 }
1165                                                 elsif ($? & 127) {
1166                                                         print STDERR "mr: chain test received signal ".($? & 127)."\n";
1167                                                 }
1168                                         }
1169                                         else {
1170                                                 push @toload, $dir.$section."/.mrconfig";
1171                                         }
1172                                 }
1173                         }
1174                 }
1175                 else {
1176                         die "$f line $line: parse error\n";
1177                 }
1178         }
1179
1180         foreach (@toload) {
1181                 loadconfig($_);
1182         }
1183 }
1184
1185 sub startingconfig {
1186         %alias=%config=%configfiles=%knownactions=%loaded=();
1187         my $datapos=tell(DATA);
1188         loadconfig(\*DATA);
1189         seek(DATA,$datapos,0); # rewind
1190 }
1191
1192 sub modifyconfig {
1193         my $f=shift;
1194         # the section to modify or add
1195         my $targetsection=shift;
1196         # fields to change in the section
1197         # To remove a field, set its value to "".
1198         my %changefields=@_;
1199
1200         my @lines;
1201         my @out;
1202
1203         if (-e $f) {
1204                 open(my $in, "<", $f) || die "mr: open $f: $!\n";
1205                 @lines=<$in>;
1206                 close $in;
1207         }
1208
1209         my $formatfield=sub {
1210                 my $field=shift;
1211                 my @value=split(/\n/, shift);
1212
1213                 return "$field = ".shift(@value)."\n".
1214                         join("", map { "\t$_\n" } @value);
1215         };
1216         my $addfields=sub {
1217                 my @blanks;
1218                 while ($out[$#out] =~ /^\s*$/) {
1219                         unshift @blanks, pop @out;
1220                 }
1221                 foreach my $field (sort keys %changefields) {
1222                         if (length $changefields{$field}) {
1223                                 push @out, "$field = $changefields{$field}\n";
1224                                 delete $changefields{$field};
1225                         }
1226                 }
1227                 push @out, @blanks;
1228         };
1229
1230         my $section;
1231         while (@lines) {
1232                 $_=shift(@lines);
1233
1234                 if (/^\s*\#/ || /^\s*$/) {
1235                         push @out, $_;
1236                 }
1237                 elsif (/^\[([^\]]*)\]\s*$/) {
1238                         if (defined $section && 
1239                             $section eq $targetsection) {
1240                                 $addfields->();
1241                         }
1242
1243                         $section=expandenv($1);
1244
1245                         push @out, $_;
1246                 }
1247                 elsif (/^(\w+)\s*=\s(.*)/) {
1248                         my $parameter=$1;
1249                         my $value=$2;
1250
1251                         # continued value
1252                         while (@lines && $lines[0]=~/^\s(.+)/) {
1253                                 shift(@lines);
1254                                 $value.="\n$1";
1255                                 chomp $value;
1256                         }
1257
1258                         if ($section eq $targetsection) {
1259                                 if (exists $changefields{$parameter}) {
1260                                         if (length $changefields{$parameter}) {
1261                                                 $value=$changefields{$parameter};
1262                                         }
1263                                         delete $changefields{$parameter};
1264                                 }
1265                         }
1266
1267                         push @out, $formatfield->($parameter, $value);
1268                 }
1269         }
1270
1271         if (defined $section && 
1272             $section eq $targetsection) {
1273                 $addfields->();
1274         }
1275         elsif (%changefields) {
1276                 push @out, "\n[$targetsection]\n";
1277                 foreach my $field (sort keys %changefields) {
1278                         if (length $changefields{$field}) {
1279                                 push @out, $formatfield->($field, $changefields{$field});
1280                         }
1281                 }
1282         }
1283
1284         open(my $out, ">", $f) || die "mr: write $f: $!\n";
1285         print $out @out;
1286         close $out;     
1287 }
1288
1289 sub dispatch {
1290         my $action=shift;
1291
1292         # actions that do not operate on all repos
1293         if ($action eq 'help') {
1294                 help(@ARGV);
1295         }
1296         elsif ($action eq 'config') {
1297                 config(@ARGV);
1298         }
1299         elsif ($action eq 'register') {
1300                 register(@ARGV);
1301         }
1302         elsif ($action eq 'bootstrap') {
1303                 bootstrap();
1304         }
1305         elsif ($action eq 'remember' ||
1306                $action eq 'offline' ||
1307                $action eq 'online') {
1308                 my @repos=selectrepos;
1309                 action($action, @{$repos[0]}) if @repos;
1310                 exit 0;
1311         }
1312
1313         if (!$jobs || $jobs > 1) {
1314                 mrs($action, selectrepos());
1315         }
1316         else {
1317                 foreach my $repo (selectrepos()) {
1318                         record($repo, action($action, @$repo));
1319                 }
1320         }
1321 }
1322
1323 sub help {
1324         exec($config{''}{DEFAULT}{help}) || die "exec: $!";
1325 }
1326
1327 sub config {
1328         if (@_ < 2) {
1329                 die "mr config: not enough parameters\n";
1330         }
1331         my $section=shift;
1332         if ($section=~/^\//) {
1333                 # try to convert to a path relative to the config file
1334                 my ($dir)=$ENV{MR_CONFIG}=~/^(.*\/)[^\/]+$/;
1335                 $dir=abs_path($dir);
1336                 $dir.="/" unless $dir=~/\/$/;
1337                 if ($section=~/^\Q$dir\E(.*)/) {
1338                         $section=$1;
1339                 }
1340         }
1341         my %changefields;
1342         foreach (@_) {
1343                 if (/^([^=]+)=(.*)$/) {
1344                         $changefields{$1}=$2;
1345                 }
1346                 else {
1347                         my $found=0;
1348                         foreach my $topdir (sort keys %config) {
1349                                 if (exists $config{$topdir}{$section} &&
1350                                     exists $config{$topdir}{$section}{$_}) {
1351                                         print $config{$topdir}{$section}{$_}."\n";
1352                                         $found=1;
1353                                         last if $section eq 'DEFAULT';
1354                                 }
1355                         }
1356                         if (! $found) {
1357                                 die "mr config: $section $_ not set\n";
1358                         }
1359                 }
1360         }
1361         modifyconfig($ENV{MR_CONFIG}, $section, %changefields) if %changefields;
1362         exit 0;
1363 }
1364
1365 sub register {
1366         if ($config_overridden) {
1367                 # Find the directory that the specified config file is
1368                 # located in.
1369                 ($directory)=abs_path($ENV{MR_CONFIG})=~/^(.*\/)[^\/]+$/;
1370         }
1371         else {
1372                 # Find the closest known mrconfig file to the current
1373                 # directory.
1374                 $directory.="/" unless $directory=~/\/$/;
1375                 my $foundconfig=0;
1376                 foreach my $topdir (reverse sort keys %config) {
1377                         next unless length $topdir;
1378                         if ($directory=~/^\Q$topdir\E/) {
1379                                 $ENV{MR_CONFIG}=$configfiles{$topdir};
1380                                 $directory=$topdir;
1381                                 $foundconfig=1;
1382                                 last;
1383                         }
1384                 }
1385                 if (! $foundconfig) {
1386                         $directory=""; # no config file, use builtin
1387                 }
1388         }
1389         if (@ARGV) {
1390                 my $subdir=shift @ARGV;
1391                 if (! chdir($subdir)) {
1392                         print STDERR "mr register: failed to chdir to $subdir: $!\n";
1393                 }
1394         }
1395
1396         $ENV{MR_REPO}=getcwd();
1397         my $command=findcommand("register", $ENV{MR_REPO}, $directory, 'DEFAULT', 0);
1398         if (! defined $command) {
1399                 die "mr register: unknown repository type\n";
1400         }
1401
1402         $ENV{MR_REPO}=~s/.*\/(.*)/$1/;
1403         $command="set -e; ".$config{$directory}{DEFAULT}{lib}."\n".
1404                 "my_action(){ $command\n }; my_action ".
1405                 join(" ", map { s/\//\/\//g; s/"/\"/g; '"'.$_.'"' } @ARGV);
1406         print "mr register: running >>$command<<\n" if $verbose;
1407         exec($command) || die "exec: $!";
1408 }
1409
1410 sub bootstrap {
1411         my $url=shift @ARGV;
1412         my $dir=shift @ARGV || ".";
1413         
1414         if (! defined $url || ! length $url) {
1415                 die "mr: bootstrap requires url\n";
1416         }
1417         
1418         # Download the config file to a temporary location.
1419         eval q{use File::Temp};
1420         die $@ if $@;
1421         my $tmpconfig=File::Temp->new();
1422         my @curlargs = ("curl", "-A", "mr", "-L", "-s", $url, "-o", $tmpconfig);
1423         push(@curlargs, "-k") if $insecure;
1424         my $curlstatus = system(@curlargs);
1425         die "mr bootstrap: invalid SSL certificate for $url (consider -k)\n" if $curlstatus >> 8 == 60;
1426         die "mr bootstrap: download of $url failed\n" if $curlstatus != 0;
1427
1428         if (! -e $dir) {
1429                 system("mkdir", "-p", $dir);
1430         }
1431         chdir($dir) || die "chdir $dir: $!";
1432
1433         # Special case to handle checkout of the "." repo, which 
1434         # would normally be skipped.
1435         my $topdir=abs_path(".")."/";
1436         my @repo=($topdir, $topdir, ".");
1437         loadconfig($tmpconfig, $topdir);
1438         record(\@repo, action("checkout", @repo, 1))
1439                 if exists $config{$topdir}{"."}{"checkout"};
1440
1441         if (-e ".mrconfig") {
1442                 print STDERR "mr bootstrap: .mrconfig file already exists, not overwriting with $url\n";
1443         }
1444         else {
1445                 eval q{use File::Copy};
1446                 die $@ if $@;
1447                 move($tmpconfig, ".mrconfig") || die "rename: $!";
1448         }
1449
1450         # Reload the config file (in case we got a different version)
1451         # and checkout everything else.
1452         startingconfig();
1453         loadconfig(".mrconfig");
1454         dispatch("checkout");
1455         @skipped=grep { abs_path($_) ne abs_path($topdir) } @skipped;
1456         showstats("bootstrap");
1457         exitstats();
1458 }
1459
1460 # alias expansion and command stemming
1461 sub expandaction {
1462         my $action=shift;
1463         if (exists $alias{$action}) {
1464                 $action=$alias{$action};
1465         }
1466         if (! exists $knownactions{$action}) {
1467                 my @matches = grep { /^\Q$action\E/ }
1468                         keys %knownactions, keys %alias;
1469                 if (@matches == 1) {
1470                         $action=$matches[0];
1471                 }
1472                 elsif (@matches == 0) {
1473                         die "mr: unknown action \"$action\" (known actions: ".
1474                                 join(", ", sort keys %knownactions).")\n";
1475                 }
1476                 else {
1477                         die "mr: ambiguous action \"$action\" (matches: ".
1478                                 join(", ", @matches).")\n";
1479                 }
1480         }
1481         return $action;
1482 }
1483
1484 sub find_nearest_mrconfig {
1485         my $dir=getcwd();
1486         while (length $dir) {
1487                 if (-e "$dir/.mrconfig") {
1488                         return "$dir/.mrconfig";
1489                 }
1490                 $dir=~s/\/[^\/]*$//;
1491         }
1492         die "no .mrconfig found in path\n";
1493 }
1494
1495 sub getopts {
1496         my @saved=@ARGV;
1497         Getopt::Long::Configure("bundling", "no_permute");
1498         my $result=GetOptions(
1499                 "d|directory=s" => sub { $directory=abs_path($_[1]) },
1500                 "c|config=s" => sub { $ENV{MR_CONFIG}=$_[1]; $config_overridden=1 },
1501                 "p|path" => sub { $ENV{MR_CONFIG}=find_nearest_mrconfig(); $config_overridden=1 },
1502                 "v|verbose" => \$verbose,
1503                 "q|quiet" => \$quiet,
1504                 "s|stats" => \$stats,
1505                 "k|insecure" => \$insecure,
1506                 "i|interactive" => \$interactive,
1507                 "n|no-recurse:i" => \$max_depth,
1508                 "j|jobs:i" => \$jobs,
1509                 "t|trust-all" => \$trust_all,
1510         );
1511         if (! $result || @ARGV < 1) {
1512                 die("Usage: mr [options] action [params ...]\n".
1513                     "(Use mr help for man page.)\n");
1514         }
1515         
1516         $ENV{MR_SWITCHES}="";
1517         foreach my $option (@saved) {
1518                 last if $option eq $ARGV[0];
1519                 $ENV{MR_SWITCHES}.="$option ";
1520         }
1521 }
1522
1523 sub init {
1524         $SIG{INT}=sub {
1525                 print STDERR "mr: interrupted\n";
1526                 exit 2;
1527         };
1528         
1529         # This can happen if it's run in a directory that was removed
1530         # or other strangeness.
1531         if (! defined $directory) {
1532                 die("mr: failed to determine working directory\n");
1533         }
1534         # Make sure MR_CONFIG is an absolute path, but don't use abs_path since
1535         # the config file might be a symlink to elsewhere, and the directory it's
1536         # in is significant.
1537         if ($ENV{MR_CONFIG} !~ /^\//) {
1538                 $ENV{MR_CONFIG}=getcwd()."/".$ENV{MR_CONFIG};
1539         }
1540         # Try to set MR_PATH to the path to the program.
1541         eval {
1542                 use FindBin qw($Bin $Script);
1543                 $ENV{MR_PATH}=$Bin."/".$Script;
1544         };
1545 }
1546         
1547 sub exitstats {
1548         if (@failed) {
1549                 exit 1;
1550         }
1551         elsif (! @ok && @skipped) {
1552                 exit 1;
1553         }
1554         else {
1555                 exit 0;
1556         }
1557 }
1558
1559 sub main {
1560         getopts();
1561         init();
1562
1563         startingconfig();
1564         loadconfig($ENV{MR_CONFIG});
1565         #use Data::Dumper; print Dumper(\%config);
1566         
1567         my $action=expandaction(shift @ARGV);
1568         dispatch($action);
1569
1570         showstats($action);
1571         exitstats();
1572 }
1573
1574 # Finally, some useful actions that mr knows about by default.
1575 # These can be overridden in ~/.mrconfig.
1576 __DATA__
1577 [ALIAS]
1578 co = checkout
1579 ci = commit
1580 ls = list
1581
1582 [DEFAULT]
1583 order = 10
1584 lib =
1585         error() {
1586                 echo "mr: $@" >&2
1587                 exit 1
1588         }
1589         warning() {
1590                 echo "mr (warning): $@" >&2
1591         }
1592         info() {
1593                 echo "mr: $@" >&2
1594         }
1595         hours_since() {
1596                 if [ -z "$1" ] || [ -z "$2" ]; then
1597                         error "mr: usage: hours_since action num"
1598                 fi
1599                 for dir in .git .svn .bzr CVS .hg _darcs _FOSSIL_; do
1600                         if [ -e "$MR_REPO/$dir" ]; then
1601                                 flagfile="$MR_REPO/$dir/.mr_last$1"
1602                                 break
1603                         fi
1604                 done
1605                 if [ -z "$flagfile" ]; then
1606                         error "cannot determine flag filename"
1607                 fi
1608                 delta=`perl -wle 'print -f shift() ? int((-M _) * 24) : 9999' "$flagfile"`
1609                 if [ "$delta" -lt "$2" ]; then
1610                         return 1
1611                 else
1612                         touch "$flagfile"
1613                         return 0
1614                 fi
1615         }
1616
1617 svn_test = test -d "$MR_REPO"/.svn
1618 git_test = test -d "$MR_REPO"/.git
1619 bzr_test = test -d "$MR_REPO"/.bzr
1620 cvs_test = test -d "$MR_REPO"/CVS
1621 hg_test  = test -d "$MR_REPO"/.hg
1622 darcs_test = test -d "$MR_REPO"/_darcs
1623 fossil_test = test -f "$MR_REPO"/_FOSSIL_
1624 git_bare_test =
1625         test -d "$MR_REPO"/refs/heads && test -d "$MR_REPO"/refs/tags &&
1626         test -d "$MR_REPO"/objects && test -f "$MR_REPO"/config &&
1627         test "`GIT_CONFIG="$MR_REPO"/config git config --get core.bare`" = true
1628
1629 svn_update = svn update "$@"
1630 git_update = git pull "$@"
1631 bzr_update = bzr merge --pull "$@"
1632 cvs_update = cvs update "$@"
1633 hg_update  = hg pull "$@" && hg update "$@"
1634 darcs_update = darcs pull -a "$@"
1635 fossil_update = fossil pull "$@"
1636
1637 svn_status = svn status "$@"
1638 git_status = git status -s "$@" || true
1639 bzr_status = bzr status --short "$@"
1640 cvs_status = cvs status "$@"
1641 hg_status  = hg status "$@"
1642 darcs_status = darcs whatsnew -ls "$@" || true
1643 fossil_status = fossil changes "$@"
1644
1645 svn_commit = svn commit "$@"
1646 git_commit = git commit -a "$@" && git push --all
1647 bzr_commit = bzr commit "$@" && bzr push
1648 cvs_commit = cvs commit "$@"
1649 hg_commit  = hg commit -m "$@" && hg push
1650 darcs_commit = darcs record -a -m "$@" && darcs push -a
1651 fossil_commit = fossil commit "$@"
1652
1653 git_record = git commit -a "$@"
1654 bzr_record = bzr commit "$@"
1655 hg_record  = hg commit -m "$@"
1656 darcs_record = darcs record -a -m "$@"
1657 fossil_record = fossil commit "$@"
1658
1659 svn_push = :
1660 git_push = git push "$@"
1661 bzr_push = bzr push "$@"
1662 cvs_push = :
1663 hg_push = hg push "$@"
1664 darcs_push = darcs push -a "$@"
1665 fossil_push = fossil push "$@"
1666
1667 svn_diff = svn diff "$@"
1668 git_diff = git diff "$@"
1669 bzr_diff = bzr diff "$@"
1670 cvs_diff = cvs diff "$@"
1671 hg_diff  = hg diff "$@"
1672 darcs_diff = darcs diff -u "$@"
1673 fossil_diff = fossil diff "$@"
1674
1675 svn_log = svn log "$@"
1676 git_log = git log "$@"
1677 bzr_log = bzr log "$@"
1678 cvs_log = cvs log "$@"
1679 hg_log  = hg log "$@"
1680 darcs_log = darcs changes "$@"
1681 git_bare_log = git log "$@"
1682 fossil_log = fossil timeline "$@"
1683
1684 svn_register =
1685         url=`LC_ALL=C svn info . | grep -i '^URL:' | cut -d ' ' -f 2`
1686         if [ -z "$url" ]; then
1687                 error "cannot determine svn url"
1688         fi
1689         echo "Registering svn url: $url in $MR_CONFIG"
1690         mr -c "$MR_CONFIG" config "`pwd`" checkout="svn co '$url' '$MR_REPO'"
1691 git_register = 
1692         url="`LC_ALL=C git config --get remote.origin.url`" || true
1693         if [ -z "$url" ]; then
1694                 error "cannot determine git url"
1695         fi
1696         echo "Registering git url: $url in $MR_CONFIG"
1697         mr -c "$MR_CONFIG" config "`pwd`" checkout="git clone '$url' '$MR_REPO'"
1698 bzr_register =
1699         url="`LC_ALL=C bzr info . | egrep -i 'checkout of branch|parent branch' | awk '{print $NF}'`"
1700         if [ -z "$url" ]; then
1701                 error "cannot determine bzr url"
1702         fi
1703         echo "Registering bzr url: $url in $MR_CONFIG"
1704         mr -c "$MR_CONFIG" config "`pwd`" checkout="bzr clone '$url' '$MR_REPO'"
1705 cvs_register =
1706         repo=`cat CVS/Repository`
1707         root=`cat CVS/Root`
1708         if [ -z "$root" ]; then
1709                 error "cannot determine cvs root"
1710                 fi
1711         echo "Registering cvs repository $repo at root $root"
1712         mr -c "$MR_CONFIG" config "`pwd`" checkout="cvs -d '$root' co -d '$MR_REPO' '$repo'"
1713 hg_register = 
1714         url=`hg showconfig paths.default`
1715         echo "Registering mercurial repo url: $url in $MR_CONFIG"
1716         mr -c "$MR_CONFIG" config "`pwd`" checkout="hg clone '$url' '$MR_REPO'"
1717 darcs_register = 
1718         url=`cat _darcs/prefs/defaultrepo`
1719         echo "Registering darcs repository $url in $MR_CONFIG"
1720         mr -c "$MR_CONFIG" config "`pwd`" checkout="darcs get '$url' '$MR_REPO'"
1721 git_bare_register = 
1722         url="`LC_ALL=C GIT_CONFIG=config git config --get remote.origin.url`" || true
1723         if [ -z "$url" ]; then
1724                 error "cannot determine git url"
1725         fi
1726         echo "Registering git url: $url in $MR_CONFIG"
1727         mr -c "$MR_CONFIG" config "`pwd`" checkout="git clone --bare '$url' '$MR_REPO'"
1728 fossil_register =
1729         url=`fossil remote-url`
1730         repo=`fossil info | grep repository | sed -e 's/repository:*.//g' -e 's/ //g'`
1731         echo "Registering fossil repository $url in $MR_CONFIG"
1732         mr -c "$MR_CONFIG" config "`pwd`" checkout="mkdir -p '$MR_REPO' && cd '$MR_REPO' && fossil open '$repo'"
1733
1734 svn_trusted_checkout = svn co $url $repo
1735 svn_alt_trusted_checkout = svn checkout $url $repo
1736 git_trusted_checkout = git clone $url $repo
1737 bzr_trusted_checkout = bzr clone $url $repo
1738 # cvs: too hard
1739 hg_trusted_checkout = hg clone $url $repo
1740 darcs_trusted_checkout = darcs get $url $repo
1741 git_bare_trusted_checkout = git clone --bare $url $repo
1742 # fossil: messy to do
1743
1744
1745 help =
1746         case `uname -s` in
1747                 SunOS)
1748                 SHOWMANFILE="man -f"
1749                 ;;
1750                 Darwin)
1751                 SHOWMANFILE="man"
1752                 ;;
1753                 *)
1754                 SHOWMANFILE="man -l"
1755                 ;;
1756         esac
1757         if [ ! -e "$MR_PATH" ]; then
1758                 error "cannot find program path"
1759         fi
1760         tmp=$(mktemp -t mr.XXXXXXXXXX) || error "mktemp failed"
1761         trap "rm -f $tmp" exit
1762         pod2man -c mr "$MR_PATH" > "$tmp" || error "pod2man failed"
1763         $SHOWMANFILE "$tmp" || error "man failed"
1764 list = true
1765 config = 
1766 bootstrap = 
1767
1768 online =
1769         if [ -s ~/.mrlog ]; then
1770                 info "running offline commands"
1771                 mv -f ~/.mrlog ~/.mrlog.old
1772                 if ! sh -e ~/.mrlog.old; then
1773                         error "offline command failed; left in ~/.mrlog.old"
1774                 fi
1775                 rm -f ~/.mrlog.old
1776         else
1777                 info "no offline commands to run"
1778         fi
1779 offline =
1780         umask 077
1781         touch ~/.mrlog
1782         info "offline mode enabled"
1783 remember =
1784         info "remembering command: 'mr $@'"
1785         command="mr -d '$(pwd)' $MR_SWITCHES"
1786         for w in "$@"; do
1787                 command="$command '$w'"
1788         done
1789         if [ ! -e ~/.mrlog ] || ! grep -q -F "$command" ~/.mrlog; then
1790                 echo "$command" >> ~/.mrlog
1791         fi
1792
1793 ed = echo "A horse is a horse, of course, of course.."
1794 T = echo "I pity the fool."
1795 right = echo "Not found."
1796
1797 # vim:sw=8:sts=0:ts=8:noet