/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

Fix tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
remote.py
1
 
# Copyright (C) 2007-2008 Canonical Ltd
 
1
# Copyright (C) 2007-2009 Jelmer Vernooij <jelmer@samba.org>
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
import bzrlib
18
 
from bzrlib import urlutils
19
 
from bzrlib.bzrdir import BzrDir, BzrDirFormat
20
 
from bzrlib.errors import NoSuchFile, NotLocalUrl
 
18
from bzrlib import (
 
19
    branch,
 
20
    tag,
 
21
    urlutils,
 
22
    )
 
23
from bzrlib.bzrdir import (
 
24
    BzrDir,
 
25
    BzrDirFormat,
 
26
    )
 
27
from bzrlib.errors import (
 
28
    BzrError,
 
29
    NoSuchFile,
 
30
    NotLocalUrl,
 
31
    )
21
32
from bzrlib.lockable_files import TransportLock
22
33
from bzrlib.repository import Repository
23
34
from bzrlib.trace import info
24
35
from bzrlib.transport import Transport
25
36
 
26
 
from bzrlib.plugins.git import git
 
37
from bzrlib.plugins.git import lazy_check_versions
 
38
lazy_check_versions()
 
39
 
27
40
from bzrlib.plugins.git.branch import GitBranch
 
41
from bzrlib.plugins.git.errors import NoSuchRef
28
42
from bzrlib.plugins.git.dir import GitDir
29
43
from bzrlib.plugins.git.foreign import ForeignBranch
30
 
from bzrlib.plugins.git.repository import GitFormat, GitRepository
 
44
from bzrlib.plugins.git.repository import (
 
45
    GitRepositoryFormat,
 
46
    GitRepository,
 
47
    )
31
48
 
 
49
import dulwich as git
 
50
from dulwich.errors import GitProtocolError
 
51
from dulwich.pack import (
 
52
    Pack,
 
53
    PackData,
 
54
    PackIndex,
 
55
    )
 
56
import os
 
57
import tempfile
32
58
import urllib
33
59
import urlparse
34
60
 
35
 
from dulwich.pack import PackData
 
61
 
 
62
# Don't run any tests on GitSmartTransport as it is not intended to be 
 
63
# a full implementation of Transport
 
64
def get_test_permutations():
 
65
    return []
36
66
 
37
67
 
38
68
class GitSmartTransport(Transport):
43
73
        assert scheme == "git"
44
74
        hostport, self._path = urllib.splithost(loc)
45
75
        (self._host, self._port) = urllib.splitnport(hostport, git.protocol.TCP_GIT_PORT)
46
 
        if _client is not None:
47
 
            self._client = _client
48
 
        else:
49
 
            self._client = git.client.TCPGitClient(self._host, self._port)
 
76
        self._client = _client
 
77
 
 
78
    def has(self, relpath):
 
79
        return False
 
80
 
 
81
    def _get_client(self):
 
82
        if self._client is not None:
 
83
            ret = self._client
 
84
            self._client = None
 
85
            return ret
 
86
        return git.client.TCPGitClient(self._host, self._port, thin_packs=False)
50
87
 
51
88
    def fetch_pack(self, determine_wants, graph_walker, pack_data, progress=None):
52
89
        if progress is None:
53
90
            def progress(text):
54
91
                info("git: %s" % text)
55
 
        self._client.fetch_pack(self._path, determine_wants, graph_walker, 
56
 
                pack_data, progress)
57
 
 
58
 
    def fetch_objects(self, determine_wants, graph_walker, progress=None):
59
 
        fd, path = tempfile.mkstemp(dir=self.pack_dir(), suffix=".pack")
60
 
        self.fetch_pack(determine_wants, graph_walker, lambda x: os.write(fd, x), progress)
61
 
        os.close(fd)
 
92
        client = self._get_client()
62
93
        try:
63
 
            p = PackData(path)
64
 
            for o in p.iterobjects():
65
 
                yield o
66
 
        finally:
67
 
            os.remove(path)
 
94
            client.fetch_pack(self._path, determine_wants, 
 
95
                graph_walker, pack_data, progress)
 
96
        except GitProtocolError, e:
 
97
            raise BzrError(e)
68
98
 
69
99
    def get(self, path):
70
100
        raise NoSuchFile(path)
71
101
 
 
102
    def abspath(self, relpath):
 
103
        return urlutils.join(self.base, relpath)
 
104
 
72
105
    def clone(self, offset=None):
73
106
        """See Transport.clone()."""
74
107
        if offset is None:
90
123
    def open_repository(self):
91
124
        return RemoteGitRepository(self, self._lockfiles)
92
125
 
93
 
    def open_branch(self):
 
126
    def open_branch(self, _unsupported=False):
94
127
        repo = self.open_repository()
95
128
        # TODO: Support for multiple branches in one bzrdir in bzrlib!
96
129
        return RemoteGitBranch(self, repo, "HEAD", self._lockfiles)
99
132
        raise NotLocalUrl(self.transport.base)
100
133
 
101
134
 
 
135
class EmptyObjectStoreIterator(dict):
 
136
 
 
137
    def iterobjects(self):
 
138
        return []
 
139
 
 
140
 
 
141
class TemporaryPackIterator(Pack):
 
142
 
 
143
    def __init__(self, path, resolve_ext_ref):
 
144
        self.resolve_ext_ref = resolve_ext_ref
 
145
        super(TemporaryPackIterator, self).__init__(path)
 
146
 
 
147
    @property
 
148
    def idx(self):
 
149
        if self._idx is None:
 
150
            self._data.create_index_v2(self._idx_path, self.resolve_ext_ref)
 
151
            self._idx = PackIndex(self._idx_path)
 
152
        return self._idx
 
153
 
 
154
    def __del__(self):
 
155
        os.remove(self._data_path)
 
156
        os.remove(self._idx_path)
 
157
 
 
158
 
102
159
class RemoteGitRepository(GitRepository):
103
160
 
104
161
    def __init__(self, gitdir, lockfiles):
105
162
        GitRepository.__init__(self, gitdir, lockfiles)
 
163
        self._refs = None
 
164
 
 
165
    def get_refs(self):
 
166
        if self._refs is not None:
 
167
            return self._refs
 
168
        def determine_wants(heads):
 
169
            self._refs = heads
 
170
            return []
 
171
        self.bzrdir.root_transport.fetch_pack(determine_wants, None, 
 
172
            lambda x: None, lambda x: mutter("git: %s" % x))
 
173
        return self._refs
106
174
 
107
175
    def fetch_pack(self, determine_wants, graph_walker, pack_data, 
108
176
                   progress=None):
109
177
        self._transport.fetch_pack(determine_wants, graph_walker, pack_data, 
110
178
            progress)
111
179
 
 
180
    def fetch_objects(self, determine_wants, graph_walker, resolve_ext_ref, progress=None):
 
181
        fd, path = tempfile.mkstemp(suffix=".pack")
 
182
        self.fetch_pack(determine_wants, graph_walker, lambda x: os.write(fd, x), progress)
 
183
        os.close(fd)
 
184
        if os.path.getsize(path) == 0:
 
185
            return EmptyObjectStoreIterator()
 
186
        return TemporaryPackIterator(path[:-len(".pack")], resolve_ext_ref)
 
187
 
 
188
 
 
189
class RemoteGitTagDict(tag.BasicTags):
 
190
 
 
191
    def __init__(self, branch):
 
192
        self.branch = branch
 
193
        self.repository = branch.repository
 
194
 
 
195
    def get_tag_dict(self):
 
196
        ret = {}
 
197
        refs = self.repository.get_refs()
 
198
        for k,v in refs.iteritems():
 
199
            if k.startswith("refs/tags/") and not k.endswith("^{}"):
 
200
                v = refs.get(k+"^{}", v)
 
201
                ret[k[len("refs/tags/"):]] = self.branch.mapping.revision_id_foreign_to_bzr(v)
 
202
        return ret
 
203
 
 
204
    def set_tag(self, name, revid):
 
205
        # FIXME: Not supported yet, should do a push of a new ref
 
206
        raise NotImplementedError(self.set_tag)
 
207
 
112
208
 
113
209
class RemoteGitBranch(GitBranch):
114
210
 
115
211
    def __init__(self, bzrdir, repository, name, lockfiles):
116
 
        def determine_wants(heads):
117
 
            self._ref = heads[name]
118
 
        bzrdir.root_transport.fetch_pack(determine_wants, None, lambda x: None, 
119
 
                             lambda x: mutter("git: %s" % x))
 
212
        heads = repository.get_refs()
 
213
        if not name in heads:
 
214
            raise NoSuchRef(name)
 
215
        self._ref = heads[name]
120
216
        super(RemoteGitBranch, self).__init__(bzrdir, repository, name, self._ref, lockfiles)
121
217
 
122
218
    def last_revision(self):
123
219
        return self.mapping.revision_id_foreign_to_bzr(self._ref)
124
220
 
 
221
    def _synchronize_history(self, destination, revision_id):
 
222
        """See Branch._synchronize_history()."""
 
223
        destination.generate_revision_history(self.last_revision())
 
224