Merge lp:~jameinel/u1db/u1db-client-commandline into lp:u1db

[John A Meinel]

This implements a 'u1db-client' commandline utility.

This allows us to do 'u1db-client get/put/create/sync' from the commandline.

I've hopefully written it in such a way that we can fairly easily test behaviour without having to run a full subprocess and parsing arguments, etc. So for each command we have:

1) setup_arg_parser() is updated to create a sub command, along with the args that the subcommand needs.
2) a 'client_*' function that gets passed an 'args' structure, this unpacks that structure into
3) a 'cmd_*' function that takes the arguments as named arguments, along with stuff like a file to write to, or a file to read from.

There is a fair amount of boilerplate for each command, but I don't think it is terribly onerous. If we were going to have 100s of commands I might think more about making it more automated.

This doesn't yet implement remote synchronization, because Samuele's patches haven't landed yet. When it does, we basically need to update cmd_sync so that it notices the target is a remote location and uses RemoteSyncTarget.

Some particular concerns:

1) 'get' writes the document content to stdout (or a named file), and the meta-information to stderr. 'put' reads the document content from stdin and the meta-information from the command-line, 'create' reads the meta-information from the command-line, but because 'doc-id' is optional it takes it as a '--doc-id=' instead of a positional argument, it also writes the meta-information to stdout.

Do we want meta-information to always be written to stderr? I like the idea of putting it into a separate channel than where the document content goes.

2) sync doesn't generate any output. We should look into our apis to try to find ways so we can do stuff like progress indication. We may want to think about putting stuff like 'number of documents' in the stream, so you can give the user X/YYY progress indication.

[Samuele Pedroni (pedronis)]

- yes, I think that if we want to segregate metadata to stderr we should do so consistently,
  if we don't then we need anyway I way for people to specify a separate metadata output file, and have a way to ask for stderr there

- I'm not sure whether about the doc_ prefixes in the metadata output and arguments, it's good because it matches the api naming on the other hand it feels a bit overkill

- I'm of the school that would have already tried to use classes for each command and tried to avoid some of the boilerplate, mostly I worry that setup_arg_parser is borderline in size

[John A Meinel (jameinel)]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

On 11/02/2011 03:11 PM, Samuele Pedroni wrote:
> - yes, I think that if we want to segregate metadata to stderr we
> should do so consistently, if we don't then we need anyway I way
> for people to specify a separate metadata output file, and have a
> way to ask for stderr there
>

I think the idea was that 'put' doesn't have any other output, so
'stdout' was left available to write whatever.

Also, 'cmd_get' takes an optional file to write to (maybe that should
be specified with '-o' instead of a positional argument). So we
*could* use that as the way for people to distinguish between actual
content and metadata. For now, I'm happy to just use stderr everywhere
if that seems preferable.

> - I'm not sure whether about the doc_ prefixes in the metadata
> output and arguments, it's good because it matches the api naming
> on the other hand it feels a bit overkill

I don't really like just saying 'id', because it feels like an
over-used 2 characters. However, I can strip them.

>
> - I'm of the school that would have already tried to use classes
> for each command and tried to avoid some of the boilerplate, mostly
> I worry that setup_arg_parser is borderline in size

I just don't know of a good framework for integrating class-based
subcommands with argparse.

bzrlib has a very nice one, but it isn't a generic available thing,
and I don't want a dependency on bzrlib. Commandant is an attempt to
pull out bzrlib's stuff into a separate lib, but I don't think it is
particularly actively maintained.

I'll do something as a follow up to this.

John
=:->
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.11 (GNU/Linux)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/

iEYEARECAAYFAk6ypU8ACgkQJdeBCYSNAAMpJQCglsPmN0RljNoCnKovQRA0h4GP
g+EAoKYrEVBEDE3EdU8u1B1HipN/rCxK
=vnc3
-----END PGP SIGNATURE-----

[lp:~jameinel/u1db/u1db-client-commandline]

102. By John A Meinel on 2011-11-03

Change the content so metadata always goes to stderr.

103. By John A Meinel on 2011-11-03

Calling things 'rev:' and 'id:' rather than 'doc_rev:' in the commandline output.

[Samuele Pedroni (pedronis)]

+1,

wondering if:

        parser.add_argument('--doc-id', default=None,
            help='Set the document identifier')

should be:

        parser.add_argument('--id', default=None, dest='doc_id',
            help='Set the document identifier')

as well or not

review: Approve

[John A Meinel (jameinel)]

It probably fits better, though it isn't how "put_doc" names the argument.
Could probably do it there, too.

John
=:->
On Nov 3, 2011 6:13 PM, "Samuele Pedroni" <email address hidden>
wrote:

> Review: Approve
>
> +1,
>
> wondering if:
>
> parser.add_argument('--doc-id', default=None,
> help='Set the document identifier')
>
> should be:
>
> parser.add_argument('--id', default=None, dest='doc_id',
> help='Set the document identifier')
>
> as well or not
> --
>
> https://code.launchpad.net/~jameinel/u1db/u1db-client-commandline/+merge/80855
> You are the owner of lp:~jameinel/u1db/u1db-client-commandline.
>

=== added file 'u1db-client'
--- u1db-client	1970-01-01 00:00:00 +0000
+++ u1db-client	2011-11-03 14:41:29 +0000
@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+# Copyright 2011 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import sys
+from u1db.commandline import client
+
+if __name__ == '__main__':
+    sys.exit(client.main(sys.argv[1:]))
+
+# vim: ft=python

=== added directory 'u1db/commandline'
=== added file 'u1db/commandline/__init__.py'
--- u1db/commandline/__init__.py	1970-01-01 00:00:00 +0000
+++ u1db/commandline/__init__.py	2011-11-03 14:41:29 +0000
@@ -0,0 +1,14 @@
+# Copyright 2011 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+

=== added file 'u1db/commandline/client.py'
--- u1db/commandline/client.py	1970-01-01 00:00:00 +0000
+++ u1db/commandline/client.py	2011-11-03 14:41:29 +0000
@@ -0,0 +1,124 @@
+# Copyright 2011 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Commandline bindings for the u1db-client program."""
+
+import argparse
+import sys
+
+from u1db import (
+    __version__ as _u1db_version,
+    sync,
+    )
+from u1db.backends import sqlite_backend
+from u1db.remote import (
+    client,
+    )
+
+
+def cmd_create(database, doc_id, in_file, out_file, err_file):
+    """Run 'create_doc'."""
+    db = sqlite_backend.SQLiteDatabase.open_database(database)
+    doc_id, doc_rev = db.create_doc(in_file.read(), doc_id=doc_id)
+    err_file.write('id: %s\nrev: %s\n' % (doc_id, doc_rev))
+
+
+def client_create(args):
+    return cmd_create(args.database, args.doc_id, args.infile, sys.stdout,
+                      sys.stderr)
+
+
+def cmd_get(database, doc_id, out_file, err_file):
+    """actually run 'get_doc' on the given parameters"""
+    db = sqlite_backend.SQLiteDatabase.open_database(database)
+    doc_rev, doc, has_conflicts = db.get_doc(doc_id)
+    out_file.write(doc)
+    err_file.write('rev: %s\n' % (doc_rev,))
+    if has_conflicts:
+        pass
+
+
+def client_get(args):
+    """Run 'get_doc' for this client"""
+    return cmd_get(args.database, args.doc_id, args.outfile, sys.stderr)
+
+
+def cmd_put(database, doc_id, old_doc_rev, in_file, out_file, err_file):
+    """run 'put_doc' and update the data."""
+    db = sqlite_backend.SQLiteDatabase.open_database(database)
+    doc_rev = db.put_doc(doc_id, old_doc_rev, in_file.read())
+    err_file.write('rev: %s\n' % (doc_rev,))
+
+
+def client_put(args):
+    """Run 'put_doc'"""
+    return cmd_put(args.database, args.doc_id, args.doc_rev, args.infile,
+                   sys.stdout, sys.stderr)
+
+
+def cmd_sync(source_db, target_db):
+    """Start a Sync request."""
+    source = sqlite_backend.SQLiteDatabase.open_database(source_db)
+    target = sqlite_backend.SQLiteDatabase.open_database(target_db)
+    st = target.get_sync_target()
+    syncer = sync.Synchronizer(source, st)
+    syncer.sync()
+
+
+def client_sync(args):
+    """Run sync"""
+    return cmd_sync(args.source, args.target)
+
+
+def setup_arg_parser():
+    p = argparse.ArgumentParser(description='Run actions from the U1DB client')
+    p.add_argument('-V', '--version', action='version', version=_u1db_version)
+    p.add_argument('-v', '--verbose', action='store_true', help='be chatty')
+    subs = p.add_subparsers(title='commands')
+    parser_create = subs.add_parser('create',
+        help='Create a new document from scratch')
+    parser_create.add_argument('database', help='The database to update')
+    parser_create.add_argument('infile', nargs='?', default=sys.stdin,
+        help='The file to read content from.')
+    parser_create.add_argument('--doc-id', default=None,
+        help='Set the document identifier')
+    parser_create.set_defaults(func=client_create)
+    parser_get = subs.add_parser('get',
+        help='Extract a document from the database')
+    parser_get.add_argument('database', help='The database to query')
+    parser_get.add_argument('doc_id', help='The document id to retrieve.')
+    parser_get.add_argument('outfile', nargs='?', default=sys.stdout,
+        help='The file to write the document to',
+        type=argparse.FileType('wb'))
+    parser_get.set_defaults(func=client_get)
+    parser_put = subs.add_parser('put', help='Add a document to the database')
+    parser_put.add_argument('database', help='The database to update')
+    parser_put.add_argument('doc_id', help='The document id to retrieve')
+    parser_put.add_argument('doc_rev',
+        help='The revision of the document (which is being superseded.)')
+    parser_put.add_argument('infile', nargs='?', default=sys.stdin,
+        help='The filename of the document that will be used for content',
+        type=argparse.FileType('rb'))
+    parser_put.set_defaults(func=client_put)
+    parser_sync = subs.add_parser('sync', help='Synchronize two databases')
+    parser_sync.add_argument('source', help='database to sync from')
+    parser_sync.add_argument('target', help='database to sync to')
+    parser_sync.set_defaults(func=client_sync)
+    return p
+
+
+def main(args):
+    p = setup_arg_parser()
+    args = p.parse_args(args)
+    return args.func(args)

=== modified file 'u1db/tests/commandline/__init__.py'
--- u1db/tests/commandline/__init__.py	2011-11-03 14:41:29 +0000
+++ u1db/tests/commandline/__init__.py	2011-11-03 14:41:29 +0000
@@ -12,4 +12,35 @@
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+import time
+
+
+def safe_close(process, timeout=0.1):
+    """Shutdown the process in the nicest fashion you can manage.
+
+    :param process: A subprocess.Popen object.
+    :param timeout: We'll try to send 'SIGTERM' but if the process is alive
+        longer that 'timeout', we'll send SIGKILL.
+    """
+    if process.poll() is not None:
+        return
+    try:
+        process.terminate()
+    except OSError, e:
+        if e.errno in (errno.ESRCH,):
+            # Process has exited
+            return
+    tend = time.time() + timeout
+    while time.time() < tend:
+        if process.poll() is not None:
+            return
+        time.sleep(0.01)
+    try:
+        process.kill()
+    except OSError, e:
+        if e.errno in (errno.ESRCH,):
+            # Process has exited
+            return
+    process.wait()
+
 

=== added file 'u1db/tests/commandline/test_client.py'
--- u1db/tests/commandline/test_client.py	1970-01-01 00:00:00 +0000
+++ u1db/tests/commandline/test_client.py	2011-11-03 14:41:29 +0000
@@ -0,0 +1,240 @@
+# Copyright 2011 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import cStringIO
+import os
+import sys
+import subprocess
+import time
+
+from u1db import (
+    __version__ as _u1db_version,
+    tests,
+    )
+from u1db.backends import (
+    sqlite_backend,
+    )
+from u1db.commandline import client
+from u1db.tests.commandline import safe_close
+
+
+class TestArgs(tests.TestCase):
+
+    def setUp(self):
+        super(TestArgs, self).setUp()
+        self.parser = client.setup_arg_parser()
+
+    def parse_args(self, args):
+        # ArgumentParser.parse_args doesn't play very nicely with a test suite,
+        # so we trap SystemExit in case something is wrong with the args we're
+        # parsing.
+        try:
+            return self.parser.parse_args(args)
+        except SystemExit, e:
+            raise AssertionError('got SystemExit')
+
+
+    def test_create(self):
+        args = self.parse_args(['create', 'test.db'])
+        self.assertEqual(client.client_create, args.func)
+        self.assertEqual('test.db', args.database)
+        self.assertEqual(None, args.doc_id)
+        self.assertEqual(sys.stdin, args.infile)
+
+    def test_create_custom_doc_id(self):
+        args = self.parse_args(['create', '--doc-id', 'xyz', 'test.db'])
+        self.assertEqual(client.client_create, args.func)
+        self.assertEqual('test.db', args.database)
+        self.assertEqual('xyz', args.doc_id)
+        self.assertEqual(sys.stdin, args.infile)
+
+    def test_get(self):
+        args = self.parse_args(['get', 'test.db', 'doc-id'])
+        self.assertEqual(client.client_get, args.func)
+        self.assertEqual('test.db', args.database)
+        self.assertEqual('doc-id', args.doc_id)
+        self.assertEqual(sys.stdout, args.outfile)
+
+    def test_get_dash(self):
+        args = self.parse_args(['get', 'test.db', 'doc-id', '-'])
+        self.assertEqual(client.client_get, args.func)
+        self.assertEqual('test.db', args.database)
+        self.assertEqual('doc-id', args.doc_id)
+        self.assertEqual(sys.stdout, args.outfile)
+
+    def test_put(self):
+        args = self.parse_args(['put', 'test.db', 'doc-id', 'old-doc-rev'])
+        self.assertEqual(client.client_put, args.func)
+        self.assertEqual('test.db', args.database)
+        self.assertEqual('doc-id', args.doc_id)
+        self.assertEqual('old-doc-rev', args.doc_rev)
+        self.assertEqual(sys.stdin, args.infile)
+
+    def test_sync(self):
+        args = self.parse_args(['sync', 'source', 'target'])
+        self.assertEqual(client.client_sync, args.func)
+        self.assertEqual('source', args.source)
+        self.assertEqual('target', args.target)
+
+
+class TestCaseWithDB(tests.TestCase):
+
+    def setUp(self):
+        super(TestCaseWithDB, self).setUp()
+        self.working_dir = self.createTempDir()
+        self.db_path = self.working_dir + '/test.db'
+        self.db = sqlite_backend.SQLitePartialExpandDatabase(self.db_path)
+        self.db._set_replica_uid('test')
+
+
+class TestCmdCreate(TestCaseWithDB):
+
+    def test_create(self):
+        out = cStringIO.StringIO()
+        err = cStringIO.StringIO()
+        inf = cStringIO.StringIO(tests.simple_doc)
+        client.cmd_create(self.db_path, 'test-id', inf, out, err)
+        doc_rev, doc, has_conflicts = self.db.get_doc('test-id')
+        self.assertEqual(tests.simple_doc, doc)
+        self.assertFalse(has_conflicts)
+        self.assertEqual('', out.getvalue())
+        self.assertEqual('id: test-id\nrev: %s\n' % (doc_rev,),
+                         err.getvalue())
+
+
+class TestCmdGet(TestCaseWithDB):
+
+    def setUp(self):
+        super(TestCmdGet, self).setUp()
+        _, self.doc_rev = self.db.create_doc(tests.simple_doc,
+                                             doc_id='my-test-doc')
+
+    def test_get_simple(self):
+        out = cStringIO.StringIO()
+        err = cStringIO.StringIO()
+        client.cmd_get(self.db_path, 'my-test-doc', out_file=out, err_file=err)
+        self.assertEqual(tests.simple_doc, out.getvalue())
+        self.assertEqual('rev: %s\n' % (self.doc_rev,),
+                         err.getvalue())
+
+
+class TestCmdPut(TestCaseWithDB):
+
+    def setUp(self):
+        super(TestCmdPut, self).setUp()
+        _, self.doc_rev = self.db.create_doc(tests.simple_doc,
+                                             doc_id='my-test-doc')
+
+    def test_put_simple(self):
+        inf = cStringIO.StringIO(tests.nested_doc)
+        out = cStringIO.StringIO()
+        err = cStringIO.StringIO()
+        client.cmd_put(self.db_path, 'my-test-doc', self.doc_rev,
+                       inf, out, err)
+        doc_rev, doc, has_conflicts = self.db.get_doc('my-test-doc')
+        self.assertEqual(tests.nested_doc, doc)
+        self.assertFalse(has_conflicts)
+        self.assertEqual('', out.getvalue())
+        self.assertEqual('rev: %s\n' % (doc_rev,),
+                         err.getvalue())
+
+
+class TestCmdSync(TestCaseWithDB):
+
+    def setUp(self):
+        super(TestCmdSync, self).setUp()
+        self.db2_path = self.working_dir + '/test2.db'
+        self.db2 = sqlite_backend.SQLitePartialExpandDatabase(self.db2_path)
+        self.db2._set_replica_uid('test2')
+        _, self.doc_rev = self.db.create_doc(tests.simple_doc,
+                                             doc_id='test-id')
+        _, self.doc2_rev = self.db2.create_doc(tests.nested_doc,
+                                               doc_id='my-test-id')
+
+    def test_sync(self):
+        client.cmd_sync(self.db_path, self.db2_path)
+        self.assertEqual((self.doc_rev, tests.simple_doc, False),
+                         self.db2.get_doc('test-id'))
+        self.assertEqual((self.doc2_rev, tests.nested_doc, False),
+                         self.db.get_doc('my-test-id'))
+
+
+class TestCommandLine(TestCaseWithDB):
+
+    def _get_u1db_client_path(self):
+        from u1db import __path__ as u1db_path
+        u1db_parent_dir = os.path.dirname(u1db_path[0])
+        return os.path.join(u1db_parent_dir, 'u1db-client')
+
+    def runU1DBClient(self, args):
+        command = [sys.executable, self._get_u1db_client_path()]
+        command.extend(args)
+        p = subprocess.Popen(command, stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        self.addCleanup(safe_close, p)
+        return p
+
+    def run_main(self, args, stdin=None):
+        if stdin is not None:
+            self.patch(sys, 'stdin', cStringIO.StringIO(stdin))
+        stdout = cStringIO.StringIO()
+        stderr = cStringIO.StringIO()
+        self.patch(sys, 'stdout', stdout)
+        self.patch(sys, 'stderr', stderr)
+        ret = client.main(args)
+        if ret is None:
+            ret = 0
+        return ret, stdout.getvalue(), stderr.getvalue()
+
+    def test_create_subprocess(self):
+        p = self.runU1DBClient(['create', '--doc-id', 'test-id', self.db_path])
+        stdout, stderr = p.communicate(tests.simple_doc)
+        self.assertEqual(0, p.returncode)
+        self.assertEqual('', stdout)
+        doc_rev, doc, has_conflicts = self.db.get_doc('test-id')
+        self.assertEqual(tests.simple_doc, doc)
+        self.assertFalse(has_conflicts)
+        self.assertEqual('id: test-id\nrev: %s\n' % (doc_rev,),
+                         stderr)
+
+    def test_get(self):
+        _, doc_rev = self.db.create_doc(tests.simple_doc, doc_id='test-id')
+        ret, stdout, stderr = self.run_main(['get', self.db_path, 'test-id'])
+        self.assertEqual(0, ret)
+        self.assertEqual(tests.simple_doc, stdout)
+        self.assertEqual('rev: %s\n' % (doc_rev,), stderr)
+
+    def test_put(self):
+        _, doc_rev = self.db.create_doc(tests.simple_doc, doc_id='test-id')
+        ret, stdout, stderr = self.run_main(
+            ['put', self.db_path, 'test-id', doc_rev],
+            stdin=tests.nested_doc)
+        doc_rev, doc, has_conflicts = self.db.get_doc('test-id')
+        self.assertFalse(has_conflicts)
+        self.assertEqual(tests.nested_doc, doc)
+        self.assertEqual(0, ret)
+        self.assertEqual('', stdout)
+        self.assertEqual('rev: %s\n' % (doc_rev,), stderr)
+
+    def test_sync(self):
+        _, doc_rev = self.db.create_doc(tests.simple_doc, doc_id='test-id')
+        self.db2_path = self.working_dir + '/test2.db'
+        self.db2 = sqlite_backend.SQLitePartialExpandDatabase(self.db2_path)
+        ret, stdout, stderr = self.run_main(
+            ['sync', self.db_path, self.db2_path])
+        self.assertEqual(0, ret)
+        self.assertEqual('', stdout)
+        self.assertEqual('', stderr)
+        self.assertEqual((doc_rev, tests.simple_doc, False),
+                         self.db2.get_doc('test-id'))

=== modified file 'u1db/tests/commandline/test_serve.py'
--- u1db/tests/commandline/test_serve.py	2011-11-03 14:41:29 +0000
+++ u1db/tests/commandline/test_serve.py	2011-11-03 14:41:29 +0000
@@ -17,42 +17,13 @@
 import socket
 import subprocess
 import sys
-import time
 
 from u1db import (
     __version__ as _u1db_version,
     tests,
     )
 from u1db.remote import client
-
-
-def safe_close(process, timeout=0.1):
-    """Shutdown the process in the nicest fashion you can manage.
-
-    :param process: A subprocess.Popen object.
-    :param timeout: We'll try to send 'SIGTERM' but if the process is alive
-        longer that 'timeout', we'll send SIGKILL.
-    """
-    if process.poll() is not None:
-        return
-    try:
-        process.terminate()
-    except OSError, e:
-        if e.errno in (errno.ESRCH,):
-            # Process has exited
-            return
-    tend = time.time() + timeout
-    while time.time() < tend:
-        if process.poll() is not None:
-            return
-        time.sleep(0.01)
-    try:
-        process.kill()
-    except OSError, e:
-        if e.errno in (errno.ESRCH,):
-            # Process has exited
-            return
-    process.wait()
+from u1db.tests.commandline import safe_close
 
 
 class TestU1DBServe(tests.TestCase):