/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

Add test for nick.

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
21
 
from bzrlib.lockable_files import TransportLock
22
 
from bzrlib.repository import Repository
23
 
from bzrlib.trace import info
24
 
from bzrlib.transport import Transport
25
 
 
26
 
from bzrlib.plugins.git import git
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
 
from bzrlib.plugins.git.foreign import ForeignBranch
31
 
from bzrlib.plugins.git.repository import GitFormat, GitRepository
32
 
 
 
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
    )
 
32
from bzrlib.lockable_files import (
 
33
    TransportLock,
 
34
    )
 
35
from bzrlib.repository import (
 
36
    Repository,
 
37
    )
 
38
from bzrlib.trace import (
 
39
    info,
 
40
    )
 
41
from bzrlib.transport import (
 
42
    Transport,
 
43
    )
 
44
 
 
45
from bzrlib.plugins.git import (
 
46
    lazy_check_versions,
 
47
    )
 
48
lazy_check_versions()
 
49
 
 
50
from bzrlib.plugins.git.branch import (
 
51
    GitBranch,
 
52
    )
 
53
from bzrlib.plugins.git.errors import (
 
54
    NoSuchRef,
 
55
    )
 
56
from bzrlib.plugins.git.dir import (
 
57
    GitDir,
 
58
    )
 
59
from bzrlib.plugins.git.foreign import (
 
60
    ForeignBranch,
 
61
    )
 
62
from bzrlib.plugins.git.repository import (
 
63
    GitRepositoryFormat,
 
64
    GitRepository,
 
65
    )
 
66
 
 
67
import dulwich as git
 
68
from dulwich.errors import (
 
69
    GitProtocolError,
 
70
    )
 
71
from dulwich.pack import (
 
72
    Pack,
 
73
    PackData,
 
74
    PackIndex,
 
75
    )
33
76
import os
34
77
import tempfile
35
78
import urllib
36
79
import urlparse
37
80
 
38
 
from dulwich.pack import PackData, Pack
 
81
 
 
82
# Don't run any tests on GitSmartTransport as it is not intended to be 
 
83
# a full implementation of Transport
 
84
def get_test_permutations():
 
85
    return []
39
86
 
40
87
 
41
88
class GitSmartTransport(Transport):
48
95
        (self._host, self._port) = urllib.splitnport(hostport, git.protocol.TCP_GIT_PORT)
49
96
        self._client = _client
50
97
 
 
98
    def has(self, relpath):
 
99
        return False
 
100
 
51
101
    def _get_client(self):
52
102
        if self._client is not None:
53
103
            ret = self._client
54
104
            self._client = None
55
105
            return ret
56
 
        return git.client.TCPGitClient(self._host, self._port)
 
106
        return git.client.TCPGitClient(self._host, self._port, thin_packs=False)
57
107
 
58
108
    def fetch_pack(self, determine_wants, graph_walker, pack_data, progress=None):
59
109
        if progress is None:
60
110
            def progress(text):
61
111
                info("git: %s" % text)
62
 
        self._get_client().fetch_pack(self._path, determine_wants, 
63
 
            graph_walker, pack_data, progress)
 
112
        client = self._get_client()
 
113
        try:
 
114
            client.fetch_pack(self._path, determine_wants, 
 
115
                graph_walker, pack_data, progress)
 
116
        except GitProtocolError, e:
 
117
            raise BzrError(e)
64
118
 
65
119
    def get(self, path):
66
120
        raise NoSuchFile(path)
89
143
    def open_repository(self):
90
144
        return RemoteGitRepository(self, self._lockfiles)
91
145
 
92
 
    def open_branch(self):
 
146
    def open_branch(self, _unsupported=False):
93
147
        repo = self.open_repository()
94
148
        # TODO: Support for multiple branches in one bzrdir in bzrlib!
95
149
        return RemoteGitBranch(self, repo, "HEAD", self._lockfiles)
98
152
        raise NotLocalUrl(self.transport.base)
99
153
 
100
154
 
 
155
class EmptyObjectStoreIterator(dict):
 
156
 
 
157
    def iterobjects(self):
 
158
        return []
 
159
 
 
160
 
 
161
class TemporaryPackIterator(Pack):
 
162
 
 
163
    def __init__(self, path, resolve_ext_ref):
 
164
        self.resolve_ext_ref = resolve_ext_ref
 
165
        super(TemporaryPackIterator, self).__init__(path)
 
166
 
 
167
    @property
 
168
    def idx(self):
 
169
        if self._idx is None:
 
170
            self._data.create_index_v2(self._idx_path, self.resolve_ext_ref)
 
171
            self._idx = PackIndex(self._idx_path)
 
172
        return self._idx
 
173
 
 
174
    def __del__(self):
 
175
        os.remove(self._data_path)
 
176
        os.remove(self._idx_path)
 
177
 
 
178
 
101
179
class RemoteGitRepository(GitRepository):
102
180
 
103
181
    def __init__(self, gitdir, lockfiles):
104
182
        GitRepository.__init__(self, gitdir, lockfiles)
 
183
        self._refs = None
 
184
 
 
185
    def get_refs(self):
 
186
        if self._refs is not None:
 
187
            return self._refs
 
188
        def determine_wants(heads):
 
189
            self._refs = heads
 
190
            return []
 
191
        self.bzrdir.root_transport.fetch_pack(determine_wants, None, 
 
192
            lambda x: None, lambda x: mutter("git: %s" % x))
 
193
        return self._refs
105
194
 
106
195
    def fetch_pack(self, determine_wants, graph_walker, pack_data, 
107
196
                   progress=None):
108
197
        self._transport.fetch_pack(determine_wants, graph_walker, pack_data, 
109
198
            progress)
110
199
 
111
 
    def fetch_objects(self, determine_wants, graph_walker, progress=None):
 
200
    def fetch_objects(self, determine_wants, graph_walker, resolve_ext_ref, progress=None):
112
201
        fd, path = tempfile.mkstemp(suffix=".pack")
113
202
        self.fetch_pack(determine_wants, graph_walker, lambda x: os.write(fd, x), progress)
114
203
        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)
 
204
        if os.path.getsize(path) == 0:
 
205
            return EmptyObjectStoreIterator()
 
206
        return TemporaryPackIterator(path[:-len(".pack")], resolve_ext_ref)
 
207
 
 
208
 
 
209
class RemoteGitTagDict(tag.BasicTags):
 
210
 
 
211
    def __init__(self, branch):
 
212
        self.branch = branch
 
213
        self.repository = branch.repository
 
214
 
 
215
    def get_tag_dict(self):
 
216
        ret = {}
 
217
        refs = self.repository.get_refs()
 
218
        for k,v in refs.iteritems():
 
219
            if k.startswith("refs/tags/") and not k.endswith("^{}"):
 
220
                v = refs.get(k+"^{}", v)
 
221
                ret[k[len("refs/tags/"):]] = self.branch.mapping.revision_id_foreign_to_bzr(v)
 
222
        return ret
 
223
 
 
224
    def set_tag(self, name, revid):
 
225
        # FIXME: Not supported yet, should do a push of a new ref
 
226
        raise NotImplementedError(self.set_tag)
123
227
 
124
228
 
125
229
class RemoteGitBranch(GitBranch):
126
230
 
127
231
    def __init__(self, bzrdir, repository, name, lockfiles):
128
 
        def determine_wants(heads):
129
 
            if not name in heads:
130
 
                raise NoSuchRef(name)
131
 
            self._ref = heads[name]
132
 
        bzrdir.root_transport.fetch_pack(determine_wants, None, lambda x: None, 
133
 
                             lambda x: mutter("git: %s" % x))
 
232
        heads = repository.get_refs()
 
233
        if not name in heads:
 
234
            raise NoSuchRef(name)
 
235
        self._ref = heads[name]
134
236
        super(RemoteGitBranch, self).__init__(bzrdir, repository, name, self._ref, lockfiles)
135
237
 
136
238
    def last_revision(self):