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
- browse files at revision 0.200.211
- compare with another revision
- download diff
- download tarball
- view history from revision 0.200.211
- Committer: Jelmer Vernooij
- Date: 2009-01-31 16:25:23 UTC
- mto: (0.312.1 master) (6883.23.1 bundle-git)
- mto: This revision was merged to the branch mainline in revision 6960.
- Revision ID: jelmer@samba.org-20090131162523-rnk1edh11i6fc97d
Add basic infrastructure for dpush.
- files added:
- foreign
- files removed:
- HACKING
- notes
- files renamed:
- tests/test_mapping.py => tests/test_ids.py
- files modified:
- .bzrignore
added
removed
remote.py
1
# Copyright (C) 2007-2009 Jelmer Vernooij <jelmer@samba.org>
1
# Copyright (C) 2007-2008 Canonical Ltd
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 (
19
branch,
20
tag,
21
ui,
22
urlutils,
23
)
24
from bzrlib.errors import (
25
BzrError,
26
InvalidRevisionId,
27
NoSuchFile,
28
NoSuchRevision,
29
NotLocalUrl,
30
)
31
from bzrlib.trace import (
32
info,
33
)
34
from bzrlib.transport import (
35
Transport,
36
)
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
37
25
38
from bzrlib.plugins.git import (
39
lazy_check_versions,
40
)
26
from bzrlib.plugins.git import lazy_check_versions
41
27
lazy_check_versions()
42
28
43
from bzrlib.plugins.git.branch import (
44
GitBranch,
45
extract_tags,
46
)
47
from bzrlib.plugins.git.errors import (
48
GitSmartRemoteNotSupported,
49
NoSuchRef,
50
)
51
from bzrlib.plugins.git.dir import (
52
GitDir,
53
)
54
from bzrlib.plugins.git.mapping import (
55
mapping_registry,
56
)
57
from bzrlib.plugins.git.repository import (
58
GitRepositoryFormat,
59
GitRepository,
60
)
29
from bzrlib.plugins.git.branch import GitBranch
30
from bzrlib.plugins.git.errors import NoSuchRef
31
from bzrlib.plugins.git.dir import GitDir
32
from bzrlib.plugins.git.foreign import ForeignBranch
33
from bzrlib.plugins.git.repository import GitFormat, GitRepository
61
34
62
import dulwich as git
63
from dulwich.errors import (
64
GitProtocolError,
65
)
66
from dulwich.pack import (
67
Pack,
68
PackData,
69
)
70
35
import os
71
36
import tempfile
72
37
import urllib
73
38
import urlparse
74
39
75
try:
76
from dulwich.pack import load_pack_index
77
except ImportError:
78
from dulwich.pack import PackIndex as load_pack_index
79
40
import dulwich as git
41
from dulwich.pack import PackData, Pack
80
42
81
43
# Don't run any tests on GitSmartTransport as it is not intended to be
82
44
# a full implementation of Transport
89
51
def __init__(self, url, _client=None):
90
52
Transport.__init__(self, url)
91
53
(scheme, _, loc, _, _) = urlparse.urlsplit(url)
54
assert scheme == "git"
92
55
hostport, self._path = urllib.splithost(loc)
93
(self._username, hostport) = urllib.splituser(hostport)
94
(self._host, self._port) = urllib.splitnport(hostport, None)
56
(self._host, self._port) = urllib.splitnport(hostport, git.protocol.TCP_GIT_PORT)
95
57
self._client = _client
96
58
97
def external_url(self):
98
return self.base
99
100
def has(self, relpath):
101
return False
102
103
59
def _get_client(self):
104
raise NotImplementedError(self._get_client)
105
106
def _get_path(self):
107
return self._path
60
if self._client is not None:
61
ret = self._client
62
self._client = None
63
return ret
64
return git.client.TCPGitClient(self._host, self._port)
108
65
109
66
def fetch_pack(self, determine_wants, graph_walker, pack_data, progress=None):
110
67
if progress is None:
111
68
def progress(text):
112
69
info("git: %s" % text)
113
client = self._get_client()
114
try:
115
return client.fetch_pack(self._get_path(), determine_wants,
116
graph_walker, pack_data, progress)
117
except GitProtocolError, e:
118
raise BzrError(e)
119
120
def send_pack(self, get_changed_refs, generate_pack_contents):
121
client = self._get_client()
122
try:
123
return client.send_pack(self._get_path(), get_changed_refs,
124
generate_pack_contents)
125
except GitProtocolError, e:
126
raise BzrError(e)
70
self._get_client().fetch_pack(self._path, determine_wants,
71
graph_walker, pack_data, progress)
127
72
128
73
def get(self, path):
129
74
raise NoSuchFile(path)
138
83
else:
139
84
newurl = urlutils.join(self.base, offset)
140
85
141
return self.__class__(newurl, self._client)
142
143
144
class TCPGitSmartTransport(GitSmartTransport):
145
146
_scheme = 'git'
147
148
def _get_client(self):
149
if self._client is not None:
150
ret = self._client
151
self._client = None
152
return ret
153
return git.client.TCPGitClient(self._host, self._port, thin_packs=False,
154
report_activity=self._report_activity)
155
156
157
class SSHGitSmartTransport(GitSmartTransport):
158
159
_scheme = 'git+ssh'
160
161
def _get_path(self):
162
if self._path.startswith("/~/"):
163
return self._path[3:]
164
return self._path
165
166
def _get_client(self):
167
if self._client is not None:
168
ret = self._client
169
self._client = None
170
return ret
171
return git.client.SSHGitClient(self._host, self._port, self._username,
172
thin_packs=False, report_activity=self._report_activity)
86
return GitSmartTransport(newurl, self._client)
173
87
174
88
175
89
class RemoteGitDir(GitDir):
179
93
self.root_transport = transport
180
94
self.transport = transport
181
95
self._lockfiles = lockfiles
182
self._mode_check_done = None
183
96
184
97
def open_repository(self):
185
98
return RemoteGitRepository(self, self._lockfiles)
186
99
187
def open_branch(self, ignore_fallbacks=False):
100
def open_branch(self, _unsupported=False):
188
101
repo = self.open_repository()
189
102
# TODO: Support for multiple branches in one bzrdir in bzrlib!
190
103
return RemoteGitBranch(self, repo, "HEAD", self._lockfiles)
193
106
raise NotLocalUrl(self.transport.base)
194
107
195
108
196
class EmptyObjectStoreIterator(dict):
197
198
def iterobjects(self):
199
return []
200
201
202
class TemporaryPackIterator(Pack):
203
204
def __init__(self, path, resolve_ext_ref):
205
super(TemporaryPackIterator, self).__init__(path)
206
self.resolve_ext_ref = resolve_ext_ref
207
208
@property
209
def index(self):
210
if self._idx is None:
211
pb = ui.ui_factory.nested_progress_bar()
212
try:
213
def report_progress(cur, total):
214
pb.update("generating index", cur, total)
215
self.data.create_index(self._idx_path, self.resolve_ext_ref,
216
progress=report_progress)
217
finally:
218
pb.finished()
219
self._idx = load_pack_index(self._idx_path)
220
return self._idx
109
class TemporaryPackIterator(object):
110
111
def __init__(self, path):
112
self.path_data = path
113
basename = path[:-len(".pack")]
114
p = PackData(path)
115
self.path_idx = basename+".idx"
116
p.create_index_v2(self.path_idx)
117
self.pack = Pack(basename)
118
self._iter = self.pack.iterobjects()
221
119
222
120
def __del__(self):
223
os.remove(self._data_path)
224
os.remove(self._idx_path)
121
os.remove(self.path_data)
122
os.remove(self.path_idx)
123
124
def next(self):
125
return (self._iter.next(), None)
126
127
def __len__(self):
128
return len(self.pack)
225
129
226
130
227
131
class RemoteGitRepository(GitRepository):
228
132
229
133
def __init__(self, gitdir, lockfiles):
230
134
GitRepository.__init__(self, gitdir, lockfiles)
231
self._refs = None
232
233
@property
234
def inventories(self):
235
raise GitSmartRemoteNotSupported()
236
237
@property
238
def revisions(self):
239
raise GitSmartRemoteNotSupported()
240
241
@property
242
def texts(self):
243
raise GitSmartRemoteNotSupported()
244
245
def get_refs(self):
246
if self._refs is not None:
247
return self._refs
248
self._refs = self.bzrdir.root_transport.fetch_pack(lambda x: [], None,
249
lambda x: None, lambda x: mutter("git: %s" % x))
250
return self._refs
251
135
252
136
def fetch_pack(self, determine_wants, graph_walker, pack_data,
253
137
progress=None):
254
return self._transport.fetch_pack(determine_wants, graph_walker,
255
pack_data, progress)
256
257
def send_pack(self, get_changed_refs, generate_pack_contents):
258
return self._transport.send_pack(get_changed_refs, generate_pack_contents)
259
260
def fetch_objects(self, determine_wants, graph_walker, resolve_ext_ref, progress=None):
138
self._transport.fetch_pack(determine_wants, graph_walker, pack_data,
139
progress)
140
141
def fetch_objects(self, determine_wants, graph_walker, progress=None):
261
142
fd, path = tempfile.mkstemp(suffix=".pack")
262
143
self.fetch_pack(determine_wants, graph_walker, lambda x: os.write(fd, x), progress)
263
144
os.close(fd)
264
if os.path.getsize(path) == 0:
265
return EmptyObjectStoreIterator()
266
return TemporaryPackIterator(path[:-len(".pack")], resolve_ext_ref)
267
268
def lookup_git_revid(self, bzr_revid):
269
# This won't work for any round-tripped bzr revisions, but it's a start..
270
try:
271
return mapping_registry.revision_id_bzr_to_foreign(bzr_revid)
272
except InvalidRevisionId:
273
raise NoSuchRevision(self, bzr_revid)
274
275
276
class RemoteGitTagDict(tag.BasicTags):
277
278
def __init__(self, branch):
279
self.branch = branch
280
self.repository = branch.repository
281
282
def get_tag_dict(self):
283
return extract_tags(self.repository.get_refs(), self.branch.mapping)
284
285
def set_tag(self, name, revid):
286
# FIXME: Not supported yet, should do a push of a new ref
287
raise NotImplementedError(self.set_tag)
145
ret = TemporaryPackIterator(path)
146
return (len(ret), iter(ret.next, None))
288
147
289
148
290
149
class RemoteGitBranch(GitBranch):
291
150
292
151
def __init__(self, bzrdir, repository, name, lockfiles):
293
self._ref = None
294
super(RemoteGitBranch, self).__init__(bzrdir, repository, name,
295
lockfiles)
296
297
def revision_history(self):
298
raise GitSmartRemoteNotSupported()
152
def determine_wants(heads):
153
if not name in heads:
154
raise NoSuchRef(name)
155
self._ref = heads[name]
156
bzrdir.root_transport.fetch_pack(determine_wants, None, lambda x: None,
157
lambda x: mutter("git: %s" % x))
158
super(RemoteGitBranch, self).__init__(bzrdir, repository, name, self._ref, lockfiles)
299
159
300
160
def last_revision(self):
301
return self.mapping.revision_id_foreign_to_bzr(self.head)
302
303
@property
304
def head(self):
305
if self._ref is not None:
306
return self._ref
307
heads = self.repository.get_refs()
308
if not self.name in heads:
309
raise NoSuchRef(name)
310
self._ref = heads[self.name]
311
return self._ref
161
return self.mapping.revision_id_foreign_to_bzr(self._ref)
312
162
313
163
def _synchronize_history(self, destination, revision_id):
314
164
"""See Branch._synchronize_history()."""
315
165
destination.generate_revision_history(self.last_revision())
316
166
317
def get_push_location(self):
318
return None
319
320
def set_push_location(self, url):
321
pass
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0