/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

Rely less on command-line git.

Show diffs side-by-side

added added

removed removed

Lines of Context:
remote.py
42
42
 
43
43
from bzrlib.plugins.git.branch import (
44
44
    GitBranch,
45
 
    extract_tags,
46
45
    )
47
46
from bzrlib.plugins.git.errors import (
48
47
    GitSmartRemoteNotSupported,
90
89
        Transport.__init__(self, url)
91
90
        (scheme, _, loc, _, _) = urlparse.urlsplit(url)
92
91
        hostport, self._path = urllib.splithost(loc)
93
 
        (self._username, hostport) = urllib.splituser(hostport)
94
92
        (self._host, self._port) = urllib.splitnport(hostport, None)
95
93
        self._client = _client
96
94
 
97
 
    def external_url(self):
98
 
        return self.base
99
 
 
100
95
    def has(self, relpath):
101
96
        return False
102
97
 
103
98
    def _get_client(self):
104
99
        raise NotImplementedError(self._get_client)
105
100
 
106
 
    def _get_path(self):
107
 
        return self._path
108
 
 
109
101
    def fetch_pack(self, determine_wants, graph_walker, pack_data, progress=None):
110
102
        if progress is None:
111
103
            def progress(text):
112
104
                info("git: %s" % text)
113
105
        client = self._get_client()
114
106
        try:
115
 
            return client.fetch_pack(self._get_path(), determine_wants, 
 
107
            client.fetch_pack(self._path, determine_wants, 
116
108
                graph_walker, pack_data, progress)
117
109
        except GitProtocolError, e:
118
110
            raise BzrError(e)
120
112
    def send_pack(self, get_changed_refs, generate_pack_contents):
121
113
        client = self._get_client()
122
114
        try:
123
 
            return client.send_pack(self._get_path(), get_changed_refs, 
 
115
            client.send_pack(self._path, get_changed_refs, 
124
116
                generate_pack_contents)
125
117
        except GitProtocolError, e:
126
118
            raise BzrError(e)
158
150
 
159
151
    _scheme = 'git+ssh'
160
152
 
161
 
    def _get_path(self):
162
 
        if self._path.startswith("/~/"):
163
 
            return self._path[3:]
164
 
        return self._path
165
 
 
166
153
    def _get_client(self):
167
154
        if self._client is not None:
168
155
            ret = self._client
169
156
            self._client = None
170
157
            return ret
171
 
        return git.client.SSHGitClient(self._host, self._port, self._username,
172
 
            thin_packs=False, report_activity=self._report_activity)
 
158
        return git.client.SSHGitClient(self._host, self._port, thin_packs=False,
 
159
            report_activity=self._report_activity)
173
160
 
174
161
 
175
162
class RemoteGitDir(GitDir):
206
193
        self.resolve_ext_ref = resolve_ext_ref
207
194
 
208
195
    @property
209
 
    def index(self):
 
196
    def idx(self):
210
197
        if self._idx is None:
 
198
            if self._data is None:
 
199
                self._data = PackData(self._data_path)
211
200
            pb = ui.ui_factory.nested_progress_bar()
212
201
            try:
213
202
                def report_progress(cur, total):
214
203
                    pb.update("generating index", cur, total)
215
 
                self.data.create_index(self._idx_path, self.resolve_ext_ref,
 
204
                self._data.create_index_v2(self._idx_path, self.resolve_ext_ref,
216
205
                    progress=report_progress)
217
206
            finally:
218
207
                pb.finished()
245
234
    def get_refs(self):
246
235
        if self._refs is not None:
247
236
            return self._refs
248
 
        self._refs = self.bzrdir.root_transport.fetch_pack(lambda x: [], None, 
 
237
        def determine_wants(heads):
 
238
            self._refs = heads
 
239
            return []
 
240
        self.bzrdir.root_transport.fetch_pack(determine_wants, None, 
249
241
            lambda x: None, lambda x: mutter("git: %s" % x))
250
242
        return self._refs
251
243
 
252
244
    def fetch_pack(self, determine_wants, graph_walker, pack_data, 
253
245
                   progress=None):
254
 
        return self._transport.fetch_pack(determine_wants, graph_walker,
255
 
                                          pack_data, progress)
 
246
        self._transport.fetch_pack(determine_wants, graph_walker, pack_data, 
 
247
            progress)
256
248
 
257
249
    def send_pack(self, get_changed_refs, generate_pack_contents):
258
 
        return self._transport.send_pack(get_changed_refs, generate_pack_contents)
 
250
        self._transport.send_pack(get_changed_refs, generate_pack_contents)
259
251
 
260
252
    def fetch_objects(self, determine_wants, graph_walker, resolve_ext_ref, progress=None):
261
253
        fd, path = tempfile.mkstemp(suffix=".pack")
280
272
        self.repository = branch.repository
281
273
 
282
274
    def get_tag_dict(self):
283
 
        return extract_tags(self.repository.get_refs(), self.branch.mapping)
 
275
        ret = {}
 
276
        refs = self.repository.get_refs()
 
277
        for k,v in refs.iteritems():
 
278
            if k.startswith("refs/tags/") and not k.endswith("^{}"):
 
279
                v = refs.get(k+"^{}", v)
 
280
                ret[k[len("refs/tags/"):]] = self.branch.mapping.revision_id_foreign_to_bzr(v)
 
281
        return ret
284
282
 
285
283
    def set_tag(self, name, revid):
286
284
        # FIXME: Not supported yet, should do a push of a new ref
290
288
class RemoteGitBranch(GitBranch):
291
289
 
292
290
    def __init__(self, bzrdir, repository, name, lockfiles):
293
 
        self._ref = None
294
 
        super(RemoteGitBranch, self).__init__(bzrdir, repository, name, 
295
 
                lockfiles)
 
291
        heads = repository.get_refs()
 
292
        if not name in heads:
 
293
            raise NoSuchRef(name)
 
294
        self._ref = heads[name]
 
295
        super(RemoteGitBranch, self).__init__(bzrdir, repository, name, self._ref, lockfiles)
296
296
 
297
297
    def revision_history(self):
298
298
        raise GitSmartRemoteNotSupported()
299
299
 
300
300
    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
 
301
        return self.mapping.revision_id_foreign_to_bzr(self._ref)
312
302
 
313
303
    def _synchronize_history(self, destination, revision_id):
314
304
        """See Branch._synchronize_history()."""
315
305
        destination.generate_revision_history(self.last_revision())
316
306
 
317
 
    def get_push_location(self):
318
 
        return None
319
 
 
320
 
    def set_push_location(self, url):
321
 
        pass