/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to remote.py

Share more code between local and remote classes, support opening remote branches.

Show diffs side-by-side

added added

removed removed

Lines of Context:
remote.py
25
25
 
26
26
from bzrlib.plugins.git import git
27
27
from bzrlib.plugins.git.branch import GitBranch
28
 
from bzrlib.plugins.git.errors import NoSuchRef
29
 
from bzrlib.plugins.git.dir import GitDir
30
28
from bzrlib.plugins.git.foreign import ForeignBranch
31
29
from bzrlib.plugins.git.repository import GitFormat, GitRepository
32
30
 
33
 
import os
34
 
import tempfile
35
31
import urllib
36
32
import urlparse
37
33
 
38
 
from dulwich.pack import PackData, Pack
39
 
 
40
34
 
41
35
class GitSmartTransport(Transport):
42
36
 
46
40
        assert scheme == "git"
47
41
        hostport, self._path = urllib.splithost(loc)
48
42
        (self._host, self._port) = urllib.splitnport(hostport, git.protocol.TCP_GIT_PORT)
49
 
        self._client = _client
50
 
 
51
 
    def _get_client(self):
52
 
        if self._client is not None:
53
 
            ret = self._client
54
 
            self._client = None
55
 
            return ret
56
 
        return git.client.TCPGitClient(self._host, self._port)
 
43
        if _client is not None:
 
44
            self._client = _client
 
45
        else:
 
46
            self._client = git.client.TCPGitClient(self._host, self._port)
57
47
 
58
48
    def fetch_pack(self, determine_wants, graph_walker, pack_data, progress=None):
59
49
        if progress is None:
60
50
            def progress(text):
61
51
                info("git: %s" % text)
62
 
        self._get_client().fetch_pack(self._path, determine_wants, 
63
 
            graph_walker, pack_data, progress)
 
52
        self._client.fetch_pack(self._path, determine_wants, graph_walker, 
 
53
                pack_data, progress)
64
54
 
65
55
    def get(self, path):
66
56
        raise NoSuchFile(path)
67
57
 
68
 
    def abspath(self, relpath):
69
 
        return urlutils.join(self.base, relpath)
70
 
 
71
58
    def clone(self, offset=None):
72
59
        """See Transport.clone()."""
73
60
        if offset is None:
78
65
        return GitSmartTransport(newurl, self._client)
79
66
 
80
67
 
81
 
class RemoteGitDir(GitDir):
 
68
class RemoteGitDir(BzrDir):
82
69
 
83
70
    def __init__(self, transport, lockfiles, format):
84
71
        self._format = format
86
73
        self.transport = transport
87
74
        self._lockfiles = lockfiles
88
75
 
 
76
    def is_supported(self):
 
77
        return True
 
78
 
89
79
    def open_repository(self):
90
80
        return RemoteGitRepository(self, self._lockfiles)
91
81
 
97
87
    def open_workingtree(self):
98
88
        raise NotLocalUrl(self.transport.base)
99
89
 
 
90
    def cloning_metadir(self, stacked=False):
 
91
        """Produce a metadir suitable for cloning with."""
 
92
        if stacked:
 
93
            return bzrlib.bzrdir.format_registry.make_bzrdir("1.6.1-rich-root")
 
94
        else:
 
95
            return bzrlib.bzrdir.format_registry.make_bzrdir("rich-root-pack")
 
96
 
100
97
 
101
98
class RemoteGitRepository(GitRepository):
102
99
 
103
100
    def __init__(self, gitdir, lockfiles):
104
101
        GitRepository.__init__(self, gitdir, lockfiles)
105
102
 
106
 
    def fetch_pack(self, determine_wants, graph_walker, pack_data, 
107
 
                   progress=None):
108
 
        self._transport.fetch_pack(determine_wants, graph_walker, pack_data, 
109
 
            progress)
110
 
 
111
 
    def fetch_objects(self, determine_wants, graph_walker, progress=None):
112
 
        fd, path = tempfile.mkstemp(suffix=".pack")
113
 
        self.fetch_pack(determine_wants, graph_walker, lambda x: os.write(fd, x), progress)
114
 
        os.close(fd)
115
 
        try:
116
 
            basename = path[:-len(".pack")]
117
 
            p = PackData(path)
118
 
            p.create_index_v2(basename+".idx")
119
 
            for o in Pack(basename).iterobjects():
120
 
                yield o
121
 
        finally:
122
 
            os.remove(path)
 
103
    def fetch_pack(self, determine_wants, graph_walker, pack_data):
 
104
        self._transport.fetch_pack(determine_wants, graph_walker, pack_data)
123
105
 
124
106
 
125
107
class RemoteGitBranch(GitBranch):
126
108
 
127
109
    def __init__(self, bzrdir, repository, name, lockfiles):
128
110
        def determine_wants(heads):
129
 
            if not name in heads:
130
 
                raise NoSuchRef(name)
131
111
            self._ref = heads[name]
132
112
        bzrdir.root_transport.fetch_pack(determine_wants, None, lambda x: None, 
133
113
                             lambda x: mutter("git: %s" % x))
134
114
        super(RemoteGitBranch, self).__init__(bzrdir, repository, name, self._ref, lockfiles)
135
115
 
136
116
    def last_revision(self):
137
 
        return self.mapping.revision_id_foreign_to_bzr(self._ref)
138
 
 
139
 
    def _synchronize_history(self, destination, revision_id):
140
 
        """See Branch._synchronize_history()."""
141
 
        destination.generate_revision_history(self.last_revision())
142
 
 
 
117
        return self._ref