clone: simplifying dest repo creation

since creating a repo raises an exception if the repo already
exists, there's no need to try to create one.
add some test for repo creation when the destination exists

mercurial/hg.py

@@ -1,236 +1,231
 # hg.py - repository classes for mercurial
 #
 # Copyright 2005, 2006 Matt Mackall <[e-mail]>
 # Copyright 2006 Vadim Gelfer <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 from node import *
 from repo import *
 from demandload import *
 from i18n import gettext as _
 demandload(globals(), "localrepo bundlerepo httprepo sshrepo statichttprepo")
 demandload(globals(), "errno lock os shutil util merge@_merge verify@_verify")
 
 def _local(path):
     return (os.path.isfile(path and util.drop_scheme('file', path)) and
             bundlerepo or localrepo)
 
 schemes = {
     'bundle': bundlerepo,
     'file': _local,
     'hg': httprepo,
     'http': httprepo,
     'https': httprepo,
     'old-http': statichttprepo,
     'ssh': sshrepo,
     'static-http': statichttprepo,
     }
 
 def _lookup(path):
     scheme = 'file'
     if path:
         c = path.find(':')
         if c > 0:
             scheme = path[:c]
     thing = schemes.get(scheme) or schemes['file']
     try:
         return thing(path)
     except TypeError:
         return thing
 
 def islocal(repo):
     '''return true if repo or path is local'''
     if isinstance(repo, str):
         try:
             return _lookup(repo).islocal(repo)
         except AttributeError:
             return False
     return repo.local()
 
 repo_setup_hooks = []
 
 def repository(ui, path=None, create=False):
     """return a repository object for the specified path"""
     repo = _lookup(path).instance(ui, path, create)
     for hook in repo_setup_hooks:
         hook(ui, repo)
     return repo
 
 def defaultdest(source):
     '''return default destination of clone if none is given'''
     return os.path.basename(os.path.normpath(source))
 
 def clone(ui, source, dest=None, pull=False, rev=None, update=True,
           stream=False):
     """Make a copy of an existing repository.
 
     Create a copy of an existing repository in a new directory.  The
     source and destination are URLs, as passed to the repository
     function.  Returns a pair of repository objects, the source and
     newly created destination.
 
     The location of the source is added to the new repository's
     .hg/hgrc file, as the default to be used for future pulls and
     pushes.
 
     If an exception is raised, the partly cloned/updated destination
     repository will be deleted.
 
     Arguments:
 
     source: repository object or URL
 
     dest: URL of destination repository to create (defaults to base
     name of source repository)
 
     pull: always pull from source repository, even in local case
 
     stream: stream raw data uncompressed from repository (fast over
     LAN, slow over WAN)
 
     rev: revision to clone up to (implies pull=True)
 
     update: update working directory after clone completes, if
     destination is local repository
     """
     if isinstance(source, str):
         src_repo = repository(ui, source)
     else:
         src_repo = source
         source = src_repo.url()
 
     if dest is None:
         dest = defaultdest(source)
 
     def localpath(path):
         if path.startswith('file://'):
             return path[7:]
         if path.startswith('file:'):
             return path[5:]
         return path
 
     dest = localpath(dest)
     source = localpath(source)
 
     if os.path.exists(dest):
         raise util.Abort(_("destination '%s' already exists"), dest)
 
     class DirCleanup(object):
         def __init__(self, dir_):
             self.rmtree = shutil.rmtree
             self.dir_ = dir_
         def close(self):
             self.dir_ = None
         def __del__(self):
             if self.dir_:
                 self.rmtree(self.dir_, True)
 
-    dest_repo = None
-    try:
-        dest_repo = repository(ui, dest)
-        raise util.Abort(_("destination '%s' already exists." % dest))
-    except RepoError:
-        dest_repo = repository(ui, dest, create=True)
+    dest_repo = repository(ui, dest, create=True)
 
     dest_path = None
     dir_cleanup = None
     if dest_repo.local():
         dest_path = os.path.realpath(dest_repo.root)
         dir_cleanup = DirCleanup(dest_path)
 
     abspath = source
     copy = False
     if src_repo.local() and dest_repo.local():
         abspath = os.path.abspath(source)
         copy = not pull and not rev
 
     src_lock, dest_lock = None, None
     if copy:
         try:
             # we use a lock here because if we race with commit, we
             # can end up with extra data in the cloned revlogs that's
             # not pointed to by changesets, thus causing verify to
             # fail
             src_lock = src_repo.lock()
         except lock.LockException:
             copy = False
 
     if copy:
         # we lock here to avoid premature writing to the target
         dest_lock = lock.lock(os.path.join(dest_path, ".hg", "lock"))
 
         # we need to remove the (empty) data dir in dest so copyfiles
         # can do its work
         os.rmdir(os.path.join(dest_path, ".hg", "data"))
         files = "data 00manifest.d 00manifest.i 00changelog.d 00changelog.i"
         for f in files.split():
             src = os.path.join(source, ".hg", f)
             dst = os.path.join(dest_path, ".hg", f)
             try:
                 util.copyfiles(src, dst)
             except OSError, inst:
                 if inst.errno != errno.ENOENT:
                     raise
 
         # we need to re-init the repo after manually copying the data
         # into it
         dest_repo = repository(ui, dest)
 
     else:
         revs = None
         if rev:
             if not src_repo.local():
                 raise util.Abort(_("clone by revision not supported yet "
                                    "for remote repositories"))
             revs = [src_repo.lookup(r) for r in rev]
 
         if dest_repo.local():
             dest_repo.clone(src_repo, heads=revs, stream=stream)
         elif src_repo.local():
             src_repo.push(dest_repo, revs=revs)
         else:
             raise util.Abort(_("clone from remote to remote not supported"))
 
     if src_lock:
         src_lock.release()
 
     if dest_repo.local():
         fp = dest_repo.opener("hgrc", "w", text=True)
         fp.write("[paths]\n")
         fp.write("default = %s\n" % abspath)
         fp.close()
 
         if dest_lock:
             dest_lock.release()
 
         if update:
             _merge.update(dest_repo, dest_repo.changelog.tip())
     if dir_cleanup:
         dir_cleanup.close()
 
     return src_repo, dest_repo
 
 def update(repo, node):
     """update the working directory to node, merging linear changes"""
     return _merge.update(repo, node)
 
 def clean(repo, node, wlock=None, show_stats=True):
     """forcibly switch the working directory to node, clobbering changes"""
     return _merge.update(repo, node, force=True, wlock=wlock,
                          show_stats=show_stats)
 
 def merge(repo, node, force=None, remind=True, wlock=None):
     """branch merge with node, resolving changes"""
     return _merge.update(repo, node, branchmerge=True, force=force,
                          remind=remind, wlock=wlock)
 
 def revert(repo, node, choose, wlock):
     """revert changes to revision in node without updating dirstate"""
     return _merge.update(repo, node, force=True, partial=choose,
                          show_stats=False, wlock=wlock)
 
 def verify(repo):
     """verify the consistency of a repository"""
     return _verify.verify(repo)

tests/test-init

@@ -1,52 +1,61
 #!/bin/sh
 
 # This test tries to exercise the ssh functionality with a dummy script
 
 cat <<'EOF' > dummyssh
 #!/bin/sh
 # this attempts to deal with relative pathnames
 cd `dirname $0`
 
 # check for proper args
 if [ $1 != "user@dummy" ] ; then
 	exit -1
 fi
 
 # check that we're in the right directory
 if [ ! -x dummyssh ] ; then
 	exit -1
 fi
 
 echo Got arguments 1:$1 2:$2 3:$3 4:$4 5:$5 >> dummylog
 $2
 EOF
 chmod +x dummyssh
 
 echo "# creating 'local'"
 hg init local
 echo this > local/foo
 hg ci --cwd local -A -m "init" -d "1000000 0"
 
+echo "#test failure"
+hg init local
+
 echo "# init+push to remote2"
 hg init -e ./dummyssh ssh://user@dummy/remote2
 hg incoming -R remote2 local
 hg push -R local -e ./dummyssh ssh://user@dummy/remote2
 
 echo "# clone to remote1"
 hg clone -e ./dummyssh local ssh://user@dummy/remote1
 
+echo "# init to existing repo"
+hg init -e ./dummyssh ssh://user@dummy/remote1
+
+echo "# clone to existing repo"
+hg clone -e ./dummyssh local ssh://user@dummy/remote1
+
 echo "# output of dummyssh"
 cat dummylog
 
 echo "# comparing repositories"
 hg tip -q -R local
 hg tip -q -R remote1
 hg tip -q -R remote2
 
 echo "# check names for repositories (clashes with URL schemes, special chars)"
 for i in bundle file hg http https old-http ssh static-http " " "with space"; do
   echo "# hg init \"$i\""
   hg init "$i"
   test -d "$i" -a -d "$i/.hg" -a -d "$i/.hg/data" && echo "ok" || echo "failed"
 done
 

tests/test-init.out

@@ -1,58 +1,64
 # creating 'local'
 adding foo
+#test failure
+abort: repository local already exists!
 # init+push to remote2
 remote: abort: repository remote2 not found!
 changeset:   0:c4e059d443be
 tag:         tip
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     init
 
 pushing to ssh://user@dummy/remote2
 searching for changes
 remote: adding changesets
 remote: adding manifests
 remote: adding file changes
 remote: added 1 changesets with 1 changes to 1 files
 # clone to remote1
 remote: abort: repository remote1 not found!
 searching for changes
-remote: abort: repository remote1 not found!
 remote: adding changesets
 remote: adding manifests
 remote: adding file changes
 remote: added 1 changesets with 1 changes to 1 files
+# init to existing repo
+abort: repository ssh://user@dummy/remote1 already exists!
+# clone to existing repo
+abort: repository ssh://user@dummy/remote1 already exists!
 # output of dummyssh
 Got arguments 1:user@dummy 2:hg -R remote2 serve --stdio 3: 4: 5:
 Got arguments 1:user@dummy 2:hg init remote2 3: 4: 5:
 Got arguments 1:user@dummy 2:hg -R remote2 serve --stdio 3: 4: 5:
 Got arguments 1:user@dummy 2:hg -R remote2 serve --stdio 3: 4: 5:
 Got arguments 1:user@dummy 2:hg -R remote1 serve --stdio 3: 4: 5:
+Got arguments 1:user@dummy 2:hg init remote1 3: 4: 5:
 Got arguments 1:user@dummy 2:hg -R remote1 serve --stdio 3: 4: 5:
-Got arguments 1:user@dummy 2:hg init remote1 3: 4: 5:
+Got arguments 1:user@dummy 2:hg -R remote1 serve --stdio 3: 4: 5:
 Got arguments 1:user@dummy 2:hg -R remote1 serve --stdio 3: 4: 5:
 # comparing repositories
 0:c4e059d443be
 0:c4e059d443be
 0:c4e059d443be
 # check names for repositories (clashes with URL schemes, special chars)
 # hg init "bundle"
 ok
 # hg init "file"
 ok
 # hg init "hg"
 ok
 # hg init "http"
 ok
 # hg init "https"
 ok
 # hg init "old-http"
 ok
 # hg init "ssh"
 ok
 # hg init "static-http"
 ok
 # hg init " "
 ok
 # hg init "with space"
 ok