serve: rename --daemon-pipefds to --daemon-postexec (BC)

Initially we use --daemon-pipefds to pass file descriptors for synchronization.
Later, in order to support Windows, --daemon-pipefds is changed to accept a
file path to unlink instead. The name is outdated since then.

chg client is designed to use flock, which will be held before starting a
server and until the client actually connects to the server it started. The
unlink synchronization approach is not so helpful in this case.

To address the issues, this patch renames pipefds to postexec and the following
patch will allow the value of --daemon-postexec to be things like
'unlink:/path/to/file' or 'none'.

contrib/chg/chg.c

@@ -1,466 +1,466 b''
 /*
  * A fast client for Mercurial command server
  *
  * Copyright (c) 2011 Yuya Nishihara <[e-mail]>
  *
  * This software may be used and distributed according to the terms of the
  * GNU General Public License version 2 or any later version.
  */
 
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/un.h>
 #include <sys/wait.h>
 #include <time.h>
 #include <unistd.h>
 
 #include "hgclient.h"
 #include "util.h"
 
 #ifndef UNIX_PATH_MAX
 #define UNIX_PATH_MAX (sizeof(((struct sockaddr_un *)NULL)->sun_path))
 #endif
 
 struct cmdserveropts {
 	char sockname[UNIX_PATH_MAX];
 	char lockfile[UNIX_PATH_MAX];
 	char pidfile[UNIX_PATH_MAX];
 	size_t argsize;
 	const char **args;
 };
 
 static void initcmdserveropts(struct cmdserveropts *opts) {
 	memset(opts, 0, sizeof(struct cmdserveropts));
 }
 
 static void freecmdserveropts(struct cmdserveropts *opts) {
 	free(opts->args);
 	opts->args = NULL;
 	opts->argsize = 0;
 }
 
 /*
  * Test if an argument is a sensitive flag that should be passed to the server.
  * Return 0 if not, otherwise the number of arguments starting from the current
  * one that should be passed to the server.
  */
 static size_t testsensitiveflag(const char *arg)
 {
 	static const struct {
 		const char *name;
 		size_t narg;
 	} flags[] = {
 		{"--config", 1},
 		{"--cwd", 1},
 		{"--repo", 1},
 		{"--repository", 1},
 		{"--traceback", 0},
 		{"-R", 1},
 	};
 	size_t i;
 	for (i = 0; i < sizeof(flags) / sizeof(flags[0]); ++i) {
 		size_t len = strlen(flags[i].name);
 		size_t narg = flags[i].narg;
 		if (memcmp(arg, flags[i].name, len) == 0) {
 			if (arg[len] == '\0') {  /* --flag (value) */
 				return narg + 1;
 			} else if (arg[len] == '=' && narg > 0) {  /* --flag=value */
 				return 1;
 			} else if (flags[i].name[1] != '-') {  /* short flag */
 				return 1;
 			}
 		}
 	}
 	return 0;
 }
 
 /*
  * Parse argv[] and put sensitive flags to opts->args
  */
 static void setcmdserverargs(struct cmdserveropts *opts,
 			     int argc, const char *argv[])
 {
 	size_t i, step;
 	opts->argsize = 0;
 	for (i = 0, step = 1; i < (size_t)argc; i += step, step = 1) {
 		if (!argv[i])
 			continue;  /* pass clang-analyse */
 		if (strcmp(argv[i], "--") == 0)
 			break;
 		size_t n = testsensitiveflag(argv[i]);
 		if (n == 0 || i + n > (size_t)argc)
 			continue;
 		opts->args = reallocx(opts->args,
 				      (n + opts->argsize) * sizeof(char *));
 		memcpy(opts->args + opts->argsize, argv + i,
 		       sizeof(char *) * n);
 		opts->argsize += n;
 		step = n;
 	}
 }
 
 static void preparesockdir(const char *sockdir)
 {
 	int r;
 	r = mkdir(sockdir, 0700);
 	if (r < 0 && errno != EEXIST)
 		abortmsg("cannot create sockdir %s (errno = %d)",
 			 sockdir, errno);
 
 	struct stat st;
 	r = lstat(sockdir, &st);
 	if (r < 0)
 		abortmsg("cannot stat %s (errno = %d)", sockdir, errno);
 	if (!S_ISDIR(st.st_mode))
 		abortmsg("cannot create sockdir %s (file exists)", sockdir);
 	if (st.st_uid != geteuid() || st.st_mode & 0077)
 		abortmsg("insecure sockdir %s", sockdir);
 }
 
 static void setcmdserveropts(struct cmdserveropts *opts)
 {
 	int r;
 	char sockdir[UNIX_PATH_MAX];
 	const char *envsockname = getenv("CHGSOCKNAME");
 	if (!envsockname) {
 		/* by default, put socket file in secure directory
 		 * (permission of socket file may be ignored on some Unices) */
 		const char *tmpdir = getenv("TMPDIR");
 		if (!tmpdir)
 			tmpdir = "/tmp";
 		r = snprintf(sockdir, sizeof(sockdir), "%s/chg%d",
 			     tmpdir, geteuid());
 		if (r < 0 || (size_t)r >= sizeof(sockdir))
 			abortmsg("too long TMPDIR (r = %d)", r);
 		preparesockdir(sockdir);
 	}
 
 	const char *basename = (envsockname) ? envsockname : sockdir;
 	const char *sockfmt = (envsockname) ? "%s" : "%s/server";
 	const char *lockfmt = (envsockname) ? "%s.lock" : "%s/lock";
 	const char *pidfmt = (envsockname) ? "%s.pid" : "%s/pid";
 	r = snprintf(opts->sockname, sizeof(opts->sockname), sockfmt, basename);
 	if (r < 0 || (size_t)r >= sizeof(opts->sockname))
 		abortmsg("too long TMPDIR or CHGSOCKNAME (r = %d)", r);
 	r = snprintf(opts->lockfile, sizeof(opts->lockfile), lockfmt, basename);
 	if (r < 0 || (size_t)r >= sizeof(opts->lockfile))
 		abortmsg("too long TMPDIR or CHGSOCKNAME (r = %d)", r);
 	r = snprintf(opts->pidfile, sizeof(opts->pidfile), pidfmt, basename);
 	if (r < 0 || (size_t)r >= sizeof(opts->pidfile))
 		abortmsg("too long TMPDIR or CHGSOCKNAME (r = %d)", r);
 }
 
 /*
  * Make lock file that indicates cmdserver process is about to start. Created
  * lock file will be deleted by server. (0: success, -1: lock exists)
  */
 static int lockcmdserver(const struct cmdserveropts *opts)
 {
 	int r;
 	char info[32];
 	r = snprintf(info, sizeof(info), "%d", getpid());
 	if (r < 0 || (size_t)r >= sizeof(info))
 		abortmsg("failed to format lock info");
 	r = symlink(info, opts->lockfile);
 	if (r < 0 && errno != EEXIST)
 		abortmsg("failed to make lock %s (errno = %d)",
 			 opts->lockfile, errno);
 	return r;
 }
 
 static void execcmdserver(const struct cmdserveropts *opts)
 {
 	const char *hgcmd = getenv("CHGHG");
 	if (!hgcmd || hgcmd[0] == '\0')
 		hgcmd = getenv("HG");
 	if (!hgcmd || hgcmd[0] == '\0')
 		hgcmd = "hg";
 
 	const char *baseargv[] = {
 		hgcmd,
 		"serve",
 		"--cwd", "/",
 		"--cmdserver", "chgunix",
 		"--address", opts->sockname,
-		"--daemon-pipefds", opts->lockfile,
+		"--daemon-postexec", opts->lockfile,
 		"--pid-file", opts->pidfile,
 		"--config", "extensions.chgserver=",
 		/* wrap root ui so that it can be disabled/enabled by config */
 		"--config", "progress.assume-tty=1",
 	};
 	size_t baseargvsize = sizeof(baseargv) / sizeof(baseargv[0]);
 	size_t argsize = baseargvsize + opts->argsize + 1;
 
 	const char **argv = mallocx(sizeof(char *) * argsize);
 	memcpy(argv, baseargv, sizeof(baseargv));
 	memcpy(argv + baseargvsize, opts->args, sizeof(char *) * opts->argsize);
 	argv[argsize - 1] = NULL;
 
 	if (execvp(hgcmd, (char **)argv) < 0)
 		abortmsg("failed to exec cmdserver (errno = %d)", errno);
 	free(argv);
 }
 
 /*
  * Sleep until lock file is deleted, i.e. cmdserver process starts listening.
  * If pid is given, it also checks if the child process fails to start.
  */
 static void waitcmdserver(const struct cmdserveropts *opts, pid_t pid)
 {
 	static const struct timespec sleepreq = {0, 10 * 1000000};
 	int pst = 0;
 
 	for (unsigned int i = 0; i < 10 * 100; i++) {
 		int r;
 		struct stat lst;
 
 		r = lstat(opts->lockfile, &lst);
 		if (r < 0 && errno == ENOENT)
 			return;  /* lock file deleted by server */
 		if (r < 0)
 			goto cleanup;
 
 		if (pid > 0) {
 			/* collect zombie if child process fails to start */
 			r = waitpid(pid, &pst, WNOHANG);
 			if (r != 0)
 				goto cleanup;
 		}
 
 		nanosleep(&sleepreq, NULL);
 	}
 
 	abortmsg("timed out waiting for cmdserver %s", opts->lockfile);
 	return;
 
 cleanup:
 	if (pid > 0)
 		/* lockfile should be made by this process */
 		unlink(opts->lockfile);
 	if (WIFEXITED(pst)) {
 		abortmsg("cmdserver exited with status %d", WEXITSTATUS(pst));
 	} else if (WIFSIGNALED(pst)) {
 		abortmsg("cmdserver killed by signal %d", WTERMSIG(pst));
 	} else {
 		abortmsg("error white waiting cmdserver");
 	}
 }
 
 /* Spawn new background cmdserver */
 static void startcmdserver(const struct cmdserveropts *opts)
 {
 	debugmsg("start cmdserver at %s", opts->sockname);
 
 	if (lockcmdserver(opts) < 0) {
 		debugmsg("lock file exists, waiting...");
 		waitcmdserver(opts, 0);
 		return;
 	}
 
 	/* remove dead cmdserver socket if any */
 	unlink(opts->sockname);
 
 	pid_t pid = fork();
 	if (pid < 0)
 		abortmsg("failed to fork cmdserver process");
 	if (pid == 0) {
 		/* bypass uisetup() of pager extension */
 		int nullfd = open("/dev/null", O_WRONLY);
 		if (nullfd >= 0) {
 			dup2(nullfd, fileno(stdout));
 			close(nullfd);
 		}
 		execcmdserver(opts);
 	} else {
 		waitcmdserver(opts, pid);
 	}
 }
 
 static void killcmdserver(const struct cmdserveropts *opts, int sig)
 {
 	FILE *fp = fopen(opts->pidfile, "r");
 	if (!fp)
 		abortmsg("cannot open %s (errno = %d)", opts->pidfile, errno);
 	int pid = 0;
 	int n = fscanf(fp, "%d", &pid);
 	fclose(fp);
 	if (n != 1 || pid <= 0)
 		abortmsg("cannot read pid from %s", opts->pidfile);
 
 	if (kill((pid_t)pid, sig) < 0) {
 		if (errno == ESRCH)
 			return;
 		abortmsg("cannot kill %d (errno = %d)", pid, errno);
 	}
 }
 
 static pid_t peerpid = 0;
 
 static void forwardsignal(int sig)
 {
 	assert(peerpid > 0);
 	if (kill(peerpid, sig) < 0)
 		abortmsg("cannot kill %d (errno = %d)", peerpid, errno);
 	debugmsg("forward signal %d", sig);
 }
 
 static void handlestopsignal(int sig)
 {
 	sigset_t unblockset, oldset;
 	struct sigaction sa, oldsa;
 	if (sigemptyset(&unblockset) < 0)
 		goto error;
 	if (sigaddset(&unblockset, sig) < 0)
 		goto error;
 	memset(&sa, 0, sizeof(sa));
 	sa.sa_handler = SIG_DFL;
 	sa.sa_flags = SA_RESTART;
 	if (sigemptyset(&sa.sa_mask) < 0)
 		goto error;
 
 	forwardsignal(sig);
 	if (raise(sig) < 0)  /* resend to self */
 		goto error;
 	if (sigaction(sig, &sa, &oldsa) < 0)
 		goto error;
 	if (sigprocmask(SIG_UNBLOCK, &unblockset, &oldset) < 0)
 		goto error;
 	/* resent signal will be handled before sigprocmask() returns */
 	if (sigprocmask(SIG_SETMASK, &oldset, NULL) < 0)
 		goto error;
 	if (sigaction(sig, &oldsa, NULL) < 0)
 		goto error;
 	return;
 
 error:
 	abortmsg("failed to handle stop signal (errno = %d)", errno);
 }
 
 static void setupsignalhandler(pid_t pid)
 {
 	if (pid <= 0)
 		return;
 	peerpid = pid;
 
 	struct sigaction sa;
 	memset(&sa, 0, sizeof(sa));
 	sa.sa_handler = forwardsignal;
 	sa.sa_flags = SA_RESTART;
 	if (sigemptyset(&sa.sa_mask) < 0)
 		goto error;
 
 	if (sigaction(SIGHUP, &sa, NULL) < 0)
 		goto error;
 	if (sigaction(SIGINT, &sa, NULL) < 0)
 		goto error;
 
 	/* terminate frontend by double SIGTERM in case of server freeze */
 	sa.sa_flags |= SA_RESETHAND;
 	if (sigaction(SIGTERM, &sa, NULL) < 0)
 		goto error;
 
 	/* propagate job control requests to worker */
 	sa.sa_handler = forwardsignal;
 	sa.sa_flags = SA_RESTART;
 	if (sigaction(SIGCONT, &sa, NULL) < 0)
 		goto error;
 	sa.sa_handler = handlestopsignal;
 	sa.sa_flags = SA_RESTART;
 	if (sigaction(SIGTSTP, &sa, NULL) < 0)
 		goto error;
 
 	return;
 
 error:
 	abortmsg("failed to set up signal handlers (errno = %d)", errno);
 }
 
 /* This implementation is based on hgext/pager.py (pre 369741ef7253) */
 static void setuppager(hgclient_t *hgc, const char *const args[],
 		       size_t argsize)
 {
 	const char *pagercmd = hgc_getpager(hgc, args, argsize);
 	if (!pagercmd)
 		return;
 
 	int pipefds[2];
 	if (pipe(pipefds) < 0)
 		return;
 	pid_t pid = fork();
 	if (pid < 0)
 		goto error;
 	if (pid == 0) {
 		close(pipefds[0]);
 		if (dup2(pipefds[1], fileno(stdout)) < 0)
 			goto error;
 		if (isatty(fileno(stderr))) {
 			if (dup2(pipefds[1], fileno(stderr)) < 0)
 				goto error;
 		}
 		close(pipefds[1]);
 		hgc_attachio(hgc);  /* reattach to pager */
 		return;
 	} else {
 		dup2(pipefds[0], fileno(stdin));
 		close(pipefds[0]);
 		close(pipefds[1]);
 
 		int r = execlp("/bin/sh", "/bin/sh", "-c", pagercmd, NULL);
 		if (r < 0) {
 			abortmsg("cannot start pager '%s' (errno = %d)",
 				 pagercmd, errno);
 		}
 		return;
 	}
 
 error:
 	close(pipefds[0]);
 	close(pipefds[1]);
 	abortmsg("failed to prepare pager (errno = %d)", errno);
 }
 
 int main(int argc, const char *argv[], const char *envp[])
 {
 	if (getenv("CHGDEBUG"))
 		enabledebugmsg();
 
 	struct cmdserveropts opts;
 	initcmdserveropts(&opts);
 	setcmdserveropts(&opts);
 	setcmdserverargs(&opts, argc, argv);
 
 	if (argc == 2) {
 		int sig = 0;
 		if (strcmp(argv[1], "--kill-chg-daemon") == 0)
 			sig = SIGTERM;
 		if (strcmp(argv[1], "--reload-chg-daemon") == 0)
 			sig = SIGHUP;
 		if (sig > 0) {
 			killcmdserver(&opts, sig);
 			return 0;
 		}
 	}
 
 	hgclient_t *hgc = hgc_open(opts.sockname);
 	if (!hgc) {
 		startcmdserver(&opts);
 		hgc = hgc_open(opts.sockname);
 	}
 	if (!hgc)
 		abortmsg("cannot open hg client");
 
 	setupsignalhandler(hgc_peerpid(hgc));
 	hgc_setenv(hgc, envp);
 	setuppager(hgc, argv + 1, argc - 1);
 	int exitcode = hgc_runcommand(hgc, argv + 1, argc - 1);
 	hgc_close(hgc);
 	freecmdserveropts(&opts);
 	return exitcode;
 }

tests/dumbhttp.py

@@ -1,55 +1,55 b''
 #!/usr/bin/env python
 
 from __future__ import absolute_import
 
 """
 Small and dumb HTTP server for use in tests.
 """
 
 import optparse
 import BaseHTTPServer
 import signal
 import SimpleHTTPServer
 import sys
 
 from mercurial import (
     cmdutil,
 )
 
 OptionParser = optparse.OptionParser
 
 class simplehttpservice(object):
     def __init__(self, host, port):
         self.address = (host, port)
     def init(self):
         self.httpd = BaseHTTPServer.HTTPServer(
             self.address, SimpleHTTPServer.SimpleHTTPRequestHandler)
     def run(self):
         self.httpd.serve_forever()
 
 if __name__ == '__main__':
     parser = OptionParser()
     parser.add_option('-p', '--port', dest='port', type='int', default=8000,
         help='TCP port to listen on', metavar='PORT')
     parser.add_option('-H', '--host', dest='host', default='localhost',
         help='hostname or IP to listen on', metavar='HOST')
     parser.add_option('--pid', dest='pid',
         help='file name where the PID of the server is stored')
     parser.add_option('-f', '--foreground', dest='foreground',
         action='store_true',
         help='do not start the HTTP server in the background')
-    parser.add_option('--daemon-pipefds')
+    parser.add_option('--daemon-postexec')
 
     (options, args) = parser.parse_args()
 
     signal.signal(signal.SIGTERM, lambda x, y: sys.exit(0))
 
     if options.foreground and options.pid:
         parser.error("options --pid and --foreground are mutually exclusive")
 
     opts = {'pid_file': options.pid,
             'daemon': not options.foreground,
-            'daemon_pipefds': options.daemon_pipefds}
+            'daemon_postexec': options.daemon_postexec}
     service = simplehttpservice(options.host, options.port)
     cmdutil.service(opts, initfn=service.init, runfn=service.run,
                     runargs=[sys.executable, __file__] + sys.argv[1:])

tests/test-completion.t

@@ -1,350 +1,350 b''
 Show all commands except debug commands
   $ hg debugcomplete
   add
   addremove
   annotate
   archive
   backout
   bisect
   bookmarks
   branch
   branches
   bundle
   cat
   clone
   commit
   config
   copy
   diff
   export
   files
   forget
   graft
   grep
   heads
   help
   identify
   import
   incoming
   init
   locate
   log
   manifest
   merge
   outgoing
   parents
   paths
   phase
   pull
   push
   recover
   remove
   rename
   resolve
   revert
   rollback
   root
   serve
   status
   summary
   tag
   tags
   tip
   unbundle
   update
   verify
   version
 
 Show all commands that start with "a"
   $ hg debugcomplete a
   add
   addremove
   annotate
   archive
 
 Do not show debug commands if there are other candidates
   $ hg debugcomplete d
   diff
 
 Show debug commands if there are no other candidates
   $ hg debugcomplete debug
   debugancestor
   debugapplystreamclonebundle
   debugbuilddag
   debugbundle
   debugcheckstate
   debugcommands
   debugcomplete
   debugconfig
   debugcreatestreamclonebundle
   debugdag
   debugdata
   debugdate
   debugdeltachain
   debugdirstate
   debugdiscovery
   debugextensions
   debugfileset
   debugfsinfo
   debuggetbundle
   debugignore
   debugindex
   debugindexdot
   debuginstall
   debugknown
   debuglabelcomplete
   debuglocks
   debugmergestate
   debugnamecomplete
   debugobsolete
   debugpathcomplete
   debugpushkey
   debugpvec
   debugrebuilddirstate
   debugrebuildfncache
   debugrename
   debugrevlog
   debugrevspec
   debugsetparents
   debugsub
   debugsuccessorssets
   debugwalk
   debugwireargs
 
 Do not show the alias of a debug command if there are other candidates
 (this should hide rawcommit)
   $ hg debugcomplete r
   recover
   remove
   rename
   resolve
   revert
   rollback
   root
 Show the alias of a debug command if there are no other candidates
   $ hg debugcomplete rawc
   
 
 Show the global options
   $ hg debugcomplete --options | sort
   --config
   --cwd
   --debug
   --debugger
   --encoding
   --encodingmode
   --help
   --hidden
   --noninteractive
   --profile
   --quiet
   --repository
   --time
   --traceback
   --verbose
   --version
   -R
   -h
   -q
   -v
   -y
 
 Show the options for the "serve" command
   $ hg debugcomplete --options serve | sort
   --accesslog
   --address
   --certificate
   --cmdserver
   --config
   --cwd
   --daemon
-  --daemon-pipefds
+  --daemon-postexec
   --debug
   --debugger
   --encoding
   --encodingmode
   --errorlog
   --help
   --hidden
   --ipv6
   --name
   --noninteractive
   --pid-file
   --port
   --prefix
   --profile
   --quiet
   --repository
   --stdio
   --style
   --templates
   --time
   --traceback
   --verbose
   --version
   --web-conf
   -6
   -A
   -E
   -R
   -a
   -d
   -h
   -n
   -p
   -q
   -t
   -v
   -y
 
 Show an error if we use --options with an ambiguous abbreviation
   $ hg debugcomplete --options s
   hg: command 's' is ambiguous:
       serve showconfig status summary
   [255]
 
 Show all commands + options
   $ hg debugcommands
   add: include, exclude, subrepos, dry-run
   annotate: rev, follow, no-follow, text, user, file, date, number, changeset, line-number, ignore-all-space, ignore-space-change, ignore-blank-lines, include, exclude, template
   clone: noupdate, updaterev, rev, branch, pull, uncompressed, ssh, remotecmd, insecure
   commit: addremove, close-branch, amend, secret, edit, interactive, include, exclude, message, logfile, date, user, subrepos
   diff: rev, change, text, git, nodates, noprefix, show-function, reverse, ignore-all-space, ignore-space-change, ignore-blank-lines, unified, stat, root, include, exclude, subrepos
   export: output, switch-parent, rev, text, git, nodates
   forget: include, exclude
   init: ssh, remotecmd, insecure
   log: follow, follow-first, date, copies, keyword, rev, removed, only-merges, user, only-branch, branch, prune, patch, git, limit, no-merges, stat, graph, style, template, include, exclude
   merge: force, rev, preview, tool
   pull: update, force, rev, bookmark, branch, ssh, remotecmd, insecure
   push: force, rev, bookmark, branch, new-branch, ssh, remotecmd, insecure
   remove: after, force, subrepos, include, exclude
-  serve: accesslog, daemon, daemon-pipefds, errorlog, port, address, prefix, name, web-conf, webdir-conf, pid-file, stdio, cmdserver, templates, style, ipv6, certificate
+  serve: accesslog, daemon, daemon-postexec, errorlog, port, address, prefix, name, web-conf, webdir-conf, pid-file, stdio, cmdserver, templates, style, ipv6, certificate
   status: all, modified, added, removed, deleted, clean, unknown, ignored, no-status, copies, print0, rev, change, include, exclude, subrepos, template
   summary: remote
   update: clean, check, date, rev, tool
   addremove: similarity, subrepos, include, exclude, dry-run
   archive: no-decode, prefix, rev, type, subrepos, include, exclude
   backout: merge, commit, no-commit, parent, rev, edit, tool, include, exclude, message, logfile, date, user
   bisect: reset, good, bad, skip, extend, command, noupdate
   bookmarks: force, rev, delete, rename, inactive, template
   branch: force, clean
   branches: active, closed, template
   bundle: force, rev, branch, base, all, type, ssh, remotecmd, insecure
   cat: output, rev, decode, include, exclude
   config: untrusted, edit, local, global
   copy: after, force, include, exclude, dry-run
   debugancestor: 
   debugapplystreamclonebundle: 
   debugbuilddag: mergeable-file, overwritten-file, new-file
   debugbundle: all, spec
   debugcheckstate: 
   debugcommands: 
   debugcomplete: options
   debugcreatestreamclonebundle: 
   debugdag: tags, branches, dots, spaces
   debugdata: changelog, manifest, dir
   debugdate: extended
   debugdeltachain: changelog, manifest, dir, template
   debugdirstate: nodates, datesort
   debugdiscovery: old, nonheads, ssh, remotecmd, insecure
   debugextensions: template
   debugfileset: rev
   debugfsinfo: 
   debuggetbundle: head, common, type
   debugignore: 
   debugindex: changelog, manifest, dir, format
   debugindexdot: changelog, manifest, dir
   debuginstall: 
   debugknown: 
   debuglabelcomplete: 
   debuglocks: force-lock, force-wlock
   debugmergestate: 
   debugnamecomplete: 
   debugobsolete: flags, record-parents, rev, date, user
   debugpathcomplete: full, normal, added, removed
   debugpushkey: 
   debugpvec: 
   debugrebuilddirstate: rev, minimal
   debugrebuildfncache: 
   debugrename: rev
   debugrevlog: changelog, manifest, dir, dump
   debugrevspec: optimize
   debugsetparents: 
   debugsub: rev
   debugsuccessorssets: 
   debugwalk: include, exclude
   debugwireargs: three, four, five, ssh, remotecmd, insecure
   files: rev, print0, include, exclude, template, subrepos
   graft: rev, continue, edit, log, force, currentdate, currentuser, date, user, tool, dry-run
   grep: print0, all, text, follow, ignore-case, files-with-matches, line-number, rev, user, date, include, exclude
   heads: rev, topo, active, closed, style, template
   help: extension, command, keyword, system
   identify: rev, num, id, branch, tags, bookmarks, ssh, remotecmd, insecure
   import: strip, base, edit, force, no-commit, bypass, partial, exact, prefix, import-branch, message, logfile, date, user, similarity
   incoming: force, newest-first, bundle, rev, bookmarks, branch, patch, git, limit, no-merges, stat, graph, style, template, ssh, remotecmd, insecure, subrepos
   locate: rev, print0, fullpath, include, exclude
   manifest: rev, all, template
   outgoing: force, rev, newest-first, bookmarks, branch, patch, git, limit, no-merges, stat, graph, style, template, ssh, remotecmd, insecure, subrepos
   parents: rev, style, template
   paths: template
   phase: public, draft, secret, force, rev
   recover: 
   rename: after, force, include, exclude, dry-run
   resolve: all, list, mark, unmark, no-status, tool, include, exclude, template
   revert: all, date, rev, no-backup, interactive, include, exclude, dry-run
   rollback: dry-run, force
   root: 
   tag: force, local, rev, remove, edit, message, date, user
   tags: template
   tip: patch, git, style, template
   unbundle: update
   verify: 
   version: 
 
   $ hg init a
   $ cd a
   $ echo fee > fee
   $ hg ci -q -Amfee
   $ hg tag fee
   $ mkdir fie
   $ echo dead > fie/dead
   $ echo live > fie/live
   $ hg bookmark fo
   $ hg branch -q fie
   $ hg ci -q -Amfie
   $ echo fo > fo
   $ hg branch -qf default
   $ hg ci -q -Amfo
   $ echo Fum > Fum
   $ hg ci -q -AmFum
   $ hg bookmark Fum
 
 Test debugpathcomplete
 
   $ hg debugpathcomplete f
   fee
   fie
   fo
   $ hg debugpathcomplete -f f
   fee
   fie/dead
   fie/live
   fo
 
   $ hg rm Fum
   $ hg debugpathcomplete -r F
   Fum
 
 Test debugnamecomplete
 
   $ hg debugnamecomplete
   Fum
   default
   fee
   fie
   fo
   tip
   $ hg debugnamecomplete f
   fee
   fie
   fo