/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 formatting.

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.dir import GitDir
29
 
from bzrlib.plugins.git.foreign import ForeignBranch
30
 
from bzrlib.plugins.git.repository import GitFormat, GitRepository
31
 
 
 
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
    )
 
75
import os
 
76
import tempfile
32
77
import urllib
33
78
import urlparse
34
79
 
35
 
from dulwich.pack import PackData
 
80
try:
 
81
    from dulwich.pack import load_pack_index
 
82
except ImportError:
 
83
    from dulwich.pack import PackIndex as load_pack_index
 
84
 
 
85
 
 
86
# Don't run any tests on GitSmartTransport as it is not intended to be 
 
87
# a full implementation of Transport
 
88
def get_test_permutations():
 
89
    return []
36
90
 
37
91
 
38
92
class GitSmartTransport(Transport):
40
94
    def __init__(self, url, _client=None):
41
95
        Transport.__init__(self, url)
42
96
        (scheme, _, loc, _, _) = urlparse.urlsplit(url)
43
 
        assert scheme == "git"
44
97
        hostport, self._path = urllib.splithost(loc)
45
98
        (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)
 
99
        self._client = _client
 
100
 
 
101
    def has(self, relpath):
 
102
        return False
 
103
 
 
104
    def _get_client(self):
 
105
        raise NotImplementedError(self._get_client)
50
106
 
51
107
    def fetch_pack(self, determine_wants, graph_walker, pack_data, progress=None):
52
108
        if progress is None:
53
109
            def progress(text):
54
110
                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)
 
111
        client = self._get_client()
62
112
        try:
63
 
            p = PackData(path)
64
 
            for o in p.iterobjects():
65
 
                yield o
66
 
        finally:
67
 
            os.remove(path)
 
113
            client.fetch_pack(self._path, determine_wants, 
 
114
                graph_walker, pack_data, progress)
 
115
        except GitProtocolError, e:
 
116
            raise BzrError(e)
68
117
 
69
118
    def get(self, path):
70
119
        raise NoSuchFile(path)
71
120
 
 
121
    def abspath(self, relpath):
 
122
        return urlutils.join(self.base, relpath)
 
123
 
72
124
    def clone(self, offset=None):
73
125
        """See Transport.clone()."""
74
126
        if offset is None:
76
128
        else:
77
129
            newurl = urlutils.join(self.base, offset)
78
130
 
79
 
        return GitSmartTransport(newurl, self._client)
 
131
        return self.__class__(newurl, self._client)
 
132
 
 
133
 
 
134
class TCPGitSmartTransport(GitSmartTransport):
 
135
 
 
136
    def _get_client(self):
 
137
        if self._client is not None:
 
138
            ret = self._client
 
139
            self._client = None
 
140
            return ret
 
141
        return git.client.TCPGitClient(self._host, self._port, thin_packs=False)
 
142
 
 
143
 
 
144
class SSHGitSmartTransport(GitSmartTransport):
 
145
 
 
146
    def _get_client(self):
 
147
        if self._client is not None:
 
148
            ret = self._client
 
149
            self._client = None
 
150
            return ret
 
151
        return git.client.SSHGitClient(self._host, self._port, thin_packs=False)
80
152
 
81
153
 
82
154
class RemoteGitDir(GitDir):
90
162
    def open_repository(self):
91
163
        return RemoteGitRepository(self, self._lockfiles)
92
164
 
93
 
    def open_branch(self):
 
165
    def open_branch(self, _unsupported=False):
94
166
        repo = self.open_repository()
95
167
        # TODO: Support for multiple branches in one bzrdir in bzrlib!
96
168
        return RemoteGitBranch(self, repo, "HEAD", self._lockfiles)
99
171
        raise NotLocalUrl(self.transport.base)
100
172
 
101
173
 
 
174
class EmptyObjectStoreIterator(dict):
 
175
 
 
176
    def iterobjects(self):
 
177
        return []
 
178
 
 
179
 
 
180
class TemporaryPackIterator(Pack):
 
181
 
 
182
    def __init__(self, path, resolve_ext_ref):
 
183
        super(TemporaryPackIterator, self).__init__(path)
 
184
        self.resolve_ext_ref = resolve_ext_ref
 
185
 
 
186
    @property
 
187
    def idx(self):
 
188
        if self._idx is None:
 
189
            if self._data is None:
 
190
                self._data = PackData(self._data_path)
 
191
            self._data.create_index_v2(self._idx_path, self.resolve_ext_ref)
 
192
            self._idx = load_pack_index(self._idx_path)
 
193
        return self._idx
 
194
 
 
195
    def __del__(self):
 
196
        os.remove(self._data_path)
 
197
        os.remove(self._idx_path)
 
198
 
 
199
 
102
200
class RemoteGitRepository(GitRepository):
103
201
 
104
202
    def __init__(self, gitdir, lockfiles):
105
203
        GitRepository.__init__(self, gitdir, lockfiles)
 
204
        self._refs = None
 
205
 
 
206
    def get_refs(self):
 
207
        if self._refs is not None:
 
208
            return self._refs
 
209
        def determine_wants(heads):
 
210
            self._refs = heads
 
211
            return []
 
212
        self.bzrdir.root_transport.fetch_pack(determine_wants, None, 
 
213
            lambda x: None, lambda x: mutter("git: %s" % x))
 
214
        return self._refs
106
215
 
107
216
    def fetch_pack(self, determine_wants, graph_walker, pack_data, 
108
217
                   progress=None):
109
218
        self._transport.fetch_pack(determine_wants, graph_walker, pack_data, 
110
219
            progress)
111
220
 
 
221
    def fetch_objects(self, determine_wants, graph_walker, resolve_ext_ref, progress=None):
 
222
        fd, path = tempfile.mkstemp(suffix=".pack")
 
223
        self.fetch_pack(determine_wants, graph_walker, lambda x: os.write(fd, x), progress)
 
224
        os.close(fd)
 
225
        if os.path.getsize(path) == 0:
 
226
            return EmptyObjectStoreIterator()
 
227
        return TemporaryPackIterator(path[:-len(".pack")], resolve_ext_ref)
 
228
 
 
229
 
 
230
class RemoteGitTagDict(tag.BasicTags):
 
231
 
 
232
    def __init__(self, branch):
 
233
        self.branch = branch
 
234
        self.repository = branch.repository
 
235
 
 
236
    def get_tag_dict(self):
 
237
        ret = {}
 
238
        refs = self.repository.get_refs()
 
239
        for k,v in refs.iteritems():
 
240
            if k.startswith("refs/tags/") and not k.endswith("^{}"):
 
241
                v = refs.get(k+"^{}", v)
 
242
                ret[k[len("refs/tags/"):]] = self.branch.mapping.revision_id_foreign_to_bzr(v)
 
243
        return ret
 
244
 
 
245
    def set_tag(self, name, revid):
 
246
        # FIXME: Not supported yet, should do a push of a new ref
 
247
        raise NotImplementedError(self.set_tag)
 
248
 
112
249
 
113
250
class RemoteGitBranch(GitBranch):
114
251
 
115
252
    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))
 
253
        heads = repository.get_refs()
 
254
        if not name in heads:
 
255
            raise NoSuchRef(name)
 
256
        self._ref = heads[name]
120
257
        super(RemoteGitBranch, self).__init__(bzrdir, repository, name, self._ref, lockfiles)
121
258
 
122
259
    def last_revision(self):
123
260
        return self.mapping.revision_id_foreign_to_bzr(self._ref)
124
261
 
 
262
    def _synchronize_history(self, destination, revision_id):
 
263
        """See Branch._synchronize_history()."""
 
264
        destination.generate_revision_history(self.last_revision())
 
265