/brz/remove-bazaar

#!/usr/bin/env python

# vim: expandtab

# Copyright (C) 2011 Jelmer Vernooij <jelmer@apache.org>

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY 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, write to the Free Software

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""Remote helper for git for accessing bzr repositories."""

import signal

import sys

def handle_sigint(signal, frame):

    sys.exit(0)

signal.signal(signal.SIGINT, handle_sigint)

CAPABILITIES = ["fetch", "option", "push"]

import optparse

import os

import bzrlib

bzrlib.initialize()

from bzrlib.plugin import load_plugins

load_plugins()

from bzrlib.controldir import ControlDir

from bzrlib.errors import NotBranchError, NoRepositoryPresent

from bzrlib.repository import InterRepository

from bzrlib.transport import get_transport_from_path

from bzrlib.plugins.git import (

    LocalGitProber,

    )

from bzrlib.plugins.git.dir import (

    BareLocalGitControlDirFormat,

    LocalGitControlDirFormat,

    )

from bzrlib.plugins.git.object_store import (

    get_object_store,

    )

from bzrlib.plugins.git.refs import (

    get_refs,

    ref_to_branch_name,

    )

from bzrlib.plugins.git.repository import (

    GitRepository,

    )

try:

    from bzrlib.plugins.fastimport import exporter as fastexporter

except ImportError:

    pass

else:

    CAPABILITIES.append("import")

options = {}

transports = []

def cmd_capabilities(argv, name, remote_dir):

    sys.stdout.write("\n".join(CAPABILITIES)+"\n\n")

    sys.stdout.flush()

def cmd_list(argv, name, remote_dir):

    try:

        repo = remote_dir.find_repository()

    except NoRepositoryPresent:

        repo = remote_dir.create_repository()

    object_store = get_object_store(repo)

    object_store.lock_read()

    try:

        refs = get_refs(remote_dir, object_store)

        for ref, git_sha1 in refs.iteritems():

            sys.stdout.write("%s %s\n" % (git_sha1, ref))

        sys.stdout.write("\n")

    finally:

        object_store.unlock()

    sys.stdout.flush()

def cmd_option(argv, name, remote_dir):

    sys.stdout.write("unsupported\n")

    sys.stdout.flush()

batchcmd = None

wants = []

def cmd_fetch(argv, name, remote_dir):

    global batchcmd, wants

    if batchcmd not in (None, "fetch"):

        raise Exception("fetch command inside other batch command")

    wants.append(tuple(argv[1:]))

    batchcmd = "fetch"

def cmd_push(argv, name, remote_dir):

    global batchcmd, wants

    if batchcmd not in (None, "push"):

        raise Exception("push command inside other batch command")

    wants.append(tuple(argv[1].split(":", 1)))

    batchcmd = "push"

def cmd_import(argv, name, remote_dir):

    dest_branch_name = ref_to_branch_name(argv[1])

    if dest_branch_name == "master":

        dest_branch_name = None

    remote_branch = remote_dir.open_branch(name=dest_branch_name)

    exporter = fastexporter.BzrFastExporter(remote_branch,

        outf=sys.stdout, git_branch=argv[1],

        checkpoint=None, import_marks_file=None,

        export_marks_file=None, revision=None,

        verbose=None, plain_format=True,

        rewrite_tags=False)

    exporter.run()

    sys.stdout.flush()

def fetch(wants, shortname, remote_dir, local_dir):

    remote_repo = remote_dir.find_repository()

    local_repo = local_dir.find_repository()

    inter = InterRepository.get(remote_repo, local_repo)

    def update_refs(heads):

        ret = {}

        for (sha1, ref) in wants:

            ret[ref] = (sha1, None)

        return ret

    if (isinstance(remote_repo, GitRepository) and

        isinstance(local_repo, GitRepository)):

        lossy = False

    else:

        lossy = True

    inter.fetch_refs(update_refs, lossy=lossy)

    sys.stdout.write("\n")

    sys.stdout.flush()

def push(wants, shortname, remote_dir, local_dir):

    for (src_ref, dest_ref) in wants:

        local_branch = local_dir.open_branch(ref=src_ref)

        dest_branch_name = ref_to_branch_name(dest_ref)

        if dest_branch_name == "master":

            dest_branch_name = None

        try:

            remote_branch = remote_dir.open_branch(name=dest_branch_name)

        except NotBranchError:

            remote_branch = remote_dir.create_branch(name=dest_branch_name)

        local_branch.push(remote_branch)

        sys.stdout.write("ok %s\n" % dest_ref)

    sys.stdout.write("\n")

    sys.stdout.flush()

commands = {

    "capabilities": cmd_capabilities,

    "list": cmd_list,

    "option": cmd_option,

    "fetch": cmd_fetch,

    "push": cmd_push,

    "import": cmd_import,

    }

parser = optparse.OptionParser()

(opts, args) = parser.parse_args()

(shortname, url) = args

try:

    remote_dir = ControlDir.open(url)

except NotBranchError:

    remote_dir = ControlDir.create(url)

try:

    git_path = os.environ["GIT_DIR"]

except KeyError:

    git_transport = get_transport_from_path(".")

    git_format = LocalGitProber().probe_transport(git_transport)

else:

    if git_path.endswith("/.git"):

        git_format = LocalGitControlDirFormat()

        git_path = git_path[:-4]

    else:

        git_format = BareLocalGitControlDirFormat()

    git_transport = get_transport_from_path(git_path)

local_dir = git_format.open(git_transport)

while True:

    l = sys.stdin.readline()

    if not l:

        break

    argv = l.strip().split()

    if argv == []:

        if batchcmd == "fetch":

            fetch(wants, shortname, remote_dir, local_dir)

        elif batchcmd == "push":

            push(wants, shortname, remote_dir, local_dir)

        elif batchcmd is None:

            break

        else:

            raise AssertionError("invalid batch %r" % batchcmd)

        batchcmd = None

    else:

        try:

           commands[argv[0]](argv, shortname, remote_dir)

        except KeyError:

           raise Exception("Unknown remote command %r" % argv)