comparison mercurial/commands.py @ 2549:e1831f06eef1

Added ability to clone from a local repository to a (new) remote one.

Rearranged the clone command a good bit to make sure it validates that
the source does exist and that the destination doesn't before doing anything.
Before I moved the source repo check it would create the destination
repository before it verified the source existed.

Moved the responsibility for creating the destination repo root directory
entirly into the localrepo class so that local to local cloning doesn't break.
This also simplifies the code a bit since it's no longer being done in both
clone and init.

Changed the names of the 'repo' and 'other' variables to 'dest_repo' and
'src_repo' to maintain my sanity.

Passes 82/83 tests. The only failure is the version number test, which I
suspect is supposed to fail since it comes from a generated file.

2546:8cb894370514

        dest = os.path.basename(os.path.normpath(source))

    if os.path.exists(dest):
        raise util.Abort(_("destination '%s' already exists"), dest)

    dest = os.path.realpath(dest)

    class Dircleanup(object):
        def __init__(self, dir_):
            self.rmtree = shutil.rmtree
            self.dir_ = dir_
            os.mkdir(dir_)
        def close(self):
            self.dir_ = None
        def __del__(self):
            if self.dir_:
                self.rmtree(self.dir_, True)

        ui.setconfig("ui", "ssh", opts['ssh'])
    if opts['remotecmd']:
        ui.setconfig("ui", "remotecmd", opts['remotecmd'])

    source = ui.expandpath(source)

    d = Dircleanup(dest)
    abspath = source
    other = hg.repository(ui, source)

    copy = False
    if other.dev() != -1:
        abspath = os.path.abspath(source)
        if not opts['pull'] and not opts['rev']:
            copy = True

    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
            l1 = other.lock()
        except lock.LockException:
            copy = False

    if copy:
        # we lock here to avoid premature writing to the target
        os.mkdir(os.path.join(dest, ".hg"))
        l2 = lock.lock(os.path.join(dest, ".hg", "lock"))

        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, ".hg", f)
            try:
                util.copyfiles(src, dst)
            except OSError, inst:
                if inst.errno != errno.ENOENT:
                    raise

        repo = hg.repository(ui, dest)

    else:
        revs = None
        if opts['rev']:
            if not other.local():
                error = _("clone -r not supported yet for remote repositories.")
                raise util.Abort(error)
            else:
                revs = [other.lookup(rev) for rev in opts['rev']]
        repo = hg.repository(ui, dest, create=1)
        repo.pull(other, heads = revs)

    f = repo.opener("hgrc", "w", text=True)
    f.write("[paths]\n")
    f.write("default = %s\n" % abspath)
    f.close()

    if not opts['noupdate']:
        doupdate(repo.ui, repo)

    d.close()

def commit(ui, repo, *pats, **opts):
    """commit the specified files or all outstanding changes

    Commit changes to the given files into the repository.

    Initialize a new repository in the given directory.  If the given
    directory does not exist, it is created.

    If no directory is given, the current directory is used.
    """
    if not os.path.exists(dest):
        os.mkdir(dest)
    hg.repository(ui, dest, create=1)

def locate(ui, repo, *pats, **opts):
    """locate files matching specific patterns

2549:e1831f06eef1

        dest = os.path.basename(os.path.normpath(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)

        ui.setconfig("ui", "ssh", opts['ssh'])
    if opts['remotecmd']:
        ui.setconfig("ui", "remotecmd", opts['remotecmd'])

    source = ui.expandpath(source)
    src_repo = hg.repository(ui, source)

    dest_repo = None
    try:
        dest_repo = hg.repository(ui, dest)
        raise util.Abort(_("destination '%s' already exists." % dest))
    except hg.RepoError:
        dest_repo = hg.repository(ui, dest, create=1)

    dest_path = None
    d = None
    if dest_repo.local():
        dest_path = os.path.realpath(dest)
        d = Dircleanup(dest_path)

    abspath = source
    copy = False
    if src_repo.local() and dest_repo.local():
        abspath = os.path.abspath(source)
        if not opts['pull'] and not opts['rev']:
            copy = True

    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
            l1 = src_repo.lock()
        except lock.LockException:
            copy = False

    if copy:
        # we lock here to avoid premature writing to the target
        l2 = lock.lock(os.path.join(dest_path, ".hg", "lock"))

	# we need to remove the (empty) data dir in dest so copyfiles can do it's 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 = hg.repository(ui, dest)

    else:
        revs = None
        if opts['rev']:
            if not src_repo.local():
                error = _("clone -r not supported yet for remote repositories.")
                raise util.Abort(error)
            else:
                revs = [src_repo.lookup(rev) for rev in opts['rev']]

        if dest_repo.local():
            dest_repo.pull(src_repo, heads = revs)
        elif src_repo.local():
            src_repo.push(dest_repo, revs = revs)
        else:
            error = _("clone from remote to remote not supported.")
            raise util.Abort(error)

    if dest_repo.local():
        f = dest_repo.opener("hgrc", "w", text=True)
        f.write("[paths]\n")
        f.write("default = %s\n" % abspath)
        f.close()

        if not opts['noupdate']:
            doupdate(dest_repo.ui, dest_repo)

    if d:
        d.close()

def commit(ui, repo, *pats, **opts):
    """commit the specified files or all outstanding changes

    Commit changes to the given files into the repository.

    Initialize a new repository in the given directory.  If the given
    directory does not exist, it is created.

    If no directory is given, the current directory is used.
    """
    hg.repository(ui, dest, create=1)

def locate(ui, repo, *pats, **opts):
    """locate files matching specific patterns