← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/foreign.py

  • Committer: Aaron Bentley
  • Date: 2009-04-22 20:08:25 UTC
  • mto: This revision was merged to the branch mainline in revision 4302.
  • Revision ID: aaron@aaronbentley.com-20090422200825-nhpatpznn1rbfz39
Restore disabled test

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/foreign.py
1
 
# Copyright (C) 2008-2011 Canonical Ltd
 
1
# Copyright (C) 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
18
18
"""Foreign branch utilities."""
19
19
 
20
20
 
21
 
from bzrlib.branch import (
22
 
    Branch,
23
 
    )
 
21
from bzrlib.branch import Branch
24
22
from bzrlib.commands import Command, Option
25
23
from bzrlib.repository import Repository
26
24
from bzrlib.revision import Revision
28
26
lazy_import(globals(), """
29
27
from bzrlib import (
30
28
    errors,
 
29
    osutils,
31
30
    registry,
32
 
    transform,
33
31
    )
34
32
""")
35
33
 
36
34
class VcsMapping(object):
37
 
    """Describes the mapping between the semantics of Bazaar and a foreign VCS.
 
35
    """Describes the mapping between the semantics of Bazaar and a foreign vcs.
38
36
 
39
37
    """
40
38
    # Whether this is an experimental mapping that is still open to changes.
43
41
    # Whether this mapping supports exporting and importing all bzr semantics.
44
42
    roundtripping = False
45
43
 
46
 
    # Prefix used when importing revisions native to the foreign VCS (as
47
 
    # opposed to roundtripping bzr-native revisions) using this mapping.
 
44
    # Prefix used when importing native foreign revisions (not roundtripped)
 
45
    # using this mapping.
48
46
    revid_prefix = None
49
47
 
50
48
    def __init__(self, vcs):
117
115
        self.mapping = mapping
118
116
 
119
117
 
 
118
def show_foreign_properties(rev):
 
119
    """Custom log displayer for foreign revision identifiers.
 
120
 
 
121
    :param rev: Revision object.
 
122
    """
 
123
    # Revision comes directly from a foreign repository
 
124
    if isinstance(rev, ForeignRevision):
 
125
        return rev.mapping.vcs.show_foreign_revid(rev.foreign_revid)
 
126
 
 
127
    # Revision was once imported from a foreign repository
 
128
    try:
 
129
        foreign_revid, mapping = \
 
130
            foreign_vcs_registry.parse_revision_id(rev.revision_id)
 
131
    except errors.InvalidRevisionId:
 
132
        return {}
 
133
 
 
134
    return mapping.vcs.show_foreign_revid(foreign_revid)
 
135
 
 
136
 
120
137
class ForeignVcs(object):
121
138
    """A foreign version control system."""
122
139
 
123
 
    branch_format = None
124
 
 
125
 
    repository_format = None
126
 
 
127
 
    def __init__(self, mapping_registry, abbreviation=None):
128
 
        """Create a new foreign vcs instance.
129
 
 
130
 
        :param mapping_registry: Registry with mappings for this VCS.
131
 
        :param abbreviation: Optional abbreviation ('bzr', 'svn', 'git', etc)
132
 
        """
133
 
        self.abbreviation = abbreviation
 
140
    def __init__(self, mapping_registry):
134
141
        self.mapping_registry = mapping_registry
135
142
 
136
143
    def show_foreign_revid(self, foreign_revid):
141
148
        """
142
149
        return { }
143
150
 
144
 
    def serialize_foreign_revid(self, foreign_revid):
145
 
        """Serialize a foreign revision id for this VCS.
146
 
 
147
 
        :param foreign_revid: Foreign revision id
148
 
        :return: Bytestring with serialized revid, will not contain any 
149
 
            newlines.
150
 
        """
151
 
        raise NotImplementedError(self.serialize_foreign_revid)
152
 
 
153
151
 
154
152
class ForeignVcsRegistry(registry.Registry):
155
153
    """Registry for Foreign VCSes.
177
175
        :param revid: The bzr revision id
178
176
        :return: tuple with foreign revid and vcs mapping
179
177
        """
180
 
        if not ":" in revid or not "-" in revid:
 
178
        if not "-" in revid:
181
179
            raise errors.InvalidRevisionId(revid, None)
182
180
        try:
183
181
            foreign_vcs = self.get(revid.split("-")[0])
223
221
        """Get the default mapping for this repository."""
224
222
        raise NotImplementedError(self.get_default_mapping)
225
223
 
 
224
    def get_inventory_xml(self, revision_id):
 
225
        """See Repository.get_inventory_xml()."""
 
226
        return self.serialise_inventory(self.get_inventory(revision_id))
 
227
 
 
228
    def get_inventory_sha1(self, revision_id):
 
229
        """Get the sha1 for the XML representation of an inventory.
 
230
 
 
231
        :param revision_id: Revision id of the inventory for which to return
 
232
         the SHA1.
 
233
        :return: XML string
 
234
        """
 
235
 
 
236
        return osutils.sha_string(self.get_inventory_xml(revision_id))
 
237
 
 
238
    def get_revision_xml(self, revision_id):
 
239
        """Return the XML representation of a revision.
 
240
 
 
241
        :param revision_id: Revision for which to return the XML.
 
242
        :return: XML string
 
243
        """
 
244
        return self._serializer.write_revision_to_string(
 
245
            self.get_revision(revision_id))
 
246
 
226
247
 
227
248
class ForeignBranch(Branch):
228
249
    """Branch that exists in a foreign version control system."""
231
252
        self.mapping = mapping
232
253
        super(ForeignBranch, self).__init__()
233
254
 
234
 
 
235
 
def update_workingtree_fileids(wt, target_tree):
236
 
    """Update the file ids in a working tree based on another tree.
237
 
 
238
 
    :param wt: Working tree in which to update file ids
239
 
    :param target_tree: Tree to retrieve new file ids from, based on path
240
 
    """
241
 
    tt = transform.TreeTransform(wt)
242
 
    try:
243
 
        for f, p, c, v, d, n, k, e in target_tree.iter_changes(wt):
244
 
            if v == (True, False):
245
 
                trans_id = tt.trans_id_tree_path(p[0])
246
 
                tt.unversion_file(trans_id)
247
 
            elif v == (False, True):
248
 
                trans_id = tt.trans_id_tree_path(p[1])
249
 
                tt.version_file(f, trans_id)
250
 
        tt.apply()
251
 
    finally:
252
 
        tt.finalize()
253
 
    if len(wt.get_parent_ids()) == 1:
254
 
        wt.set_parent_trees([(target_tree.get_revision_id(), target_tree)])
255
 
    else:
256
 
        wt.set_last_revision(target_tree.get_revision_id())
 
255
    def dpull(self, source, stop_revision=None):
 
256
        """Pull deltas from another branch.
 
257
 
 
258
        :note: This does not, like pull, retain the revision ids from 
 
259
            the source branch and will, rather than adding bzr-specific 
 
260
            metadata, push only those semantics of the revision that can be 
 
261
            natively represented by this branch' VCS.
 
262
 
 
263
        :param source: Source branch
 
264
        :param stop_revision: Revision to pull, defaults to last revision.
 
265
        :return: Dictionary mapping revision ids from the source branch 
 
266
            to new revision ids in the target branch, for each 
 
267
            revision that was pull.
 
268
        """
 
269
        raise NotImplementedError(self.dpull)
 
270
 
 
271
 
 
272
def _determine_fileid_renames(old_inv, new_inv):
 
273
    """Determine the file ids based on a old and a new inventory that 
 
274
    are equal in content.
 
275
 
 
276
    :param old_inv: Old inventory
 
277
    :param new_inv: New inventory
 
278
    :return: Dictionary a (old_id, new_id) tuple for each path in the 
 
279
        inventories.
 
280
    """
 
281
    ret = {}
 
282
    if len(old_inv) != len(new_inv):
 
283
        raise AssertionError("Inventories are not of the same size")
 
284
    for old_file_id in old_inv:
 
285
        path = old_inv.id2path(old_file_id)
 
286
        new_file_id = new_inv.path2id(path)
 
287
        if new_file_id is None:
 
288
            raise AssertionError(
 
289
                "Unable to find %s in new inventory" % old_file_id)
 
290
        ret[path] = (old_file_id, new_file_id)
 
291
    return ret
 
292
 
 
293
 
 
294
def update_workinginv_fileids(wt, old_inv, new_inv):
 
295
    """Update all file ids in wt according to old_tree/new_tree. 
 
296
 
 
297
    old_tree and new_tree should be two RevisionTree's that differ only
 
298
    in file ids.
 
299
    """
 
300
    fileid_renames = _determine_fileid_renames(old_inv, new_inv)
 
301
    old_fileids = []
 
302
    new_fileids = []
 
303
    new_root_id = None
 
304
    # Adjust file ids in working tree
 
305
    # Sorted, so we process parents before children
 
306
    for path in sorted(fileid_renames.keys()):
 
307
        (old_fileid, new_fileid) = fileid_renames[path]
 
308
        if path != "":
 
309
            new_fileids.append((path, new_fileid))
 
310
            # unversion() works recursively so we only have to unversion the 
 
311
            # top-level. Unfortunately unversioning / is not supported yet, 
 
312
            # so unversion its children instead and use set_root_id() for /
 
313
            if old_inv[old_fileid].parent_id == old_inv.root.file_id:
 
314
                old_fileids.append(old_fileid)
 
315
        else:
 
316
            new_root_id = new_fileid
 
317
    new_fileids.reverse()
 
318
    wt.unversion(old_fileids)
 
319
    if new_root_id is not None:
 
320
        wt.set_root_id(new_root_id)
 
321
    wt.add([x[0] for x in new_fileids], [x[1] for x in new_fileids])
 
322
    wt.set_last_revision(new_inv.revision_id)
257
323
 
258
324
 
259
325
class cmd_dpush(Command):
260
 
    __doc__ = """Push into a different VCS without any custom bzr metadata.
 
326
    """Push diffs into a foreign version control system without any 
 
327
    Bazaar-specific metadata.
261
328
 
262
 
    This will afterwards rebase the local branch on the remote
 
329
    This will afterwards rebase the local Bazaar branch on the remote
263
330
    branch unless the --no-rebase option is used, in which case 
264
 
    the two branches will be out of sync after the push. 
 
331
    the two branches will be out of sync. 
265
332
    """
266
333
    hidden = True
267
334
    takes_args = ['location?']
268
 
    takes_options = [
269
 
        'remember',
270
 
        Option('directory',
271
 
               help='Branch to push from, '
272
 
               'rather than the one containing the working directory.',
273
 
               short_name='d',
274
 
               type=unicode,
275
 
               ),
276
 
        Option('no-rebase', help="Do not rebase after push."),
277
 
        Option('strict',
278
 
               help='Refuse to push if there are uncommitted changes in'
279
 
               ' the working tree, --no-strict disables the check.'),
280
 
        ]
 
335
    takes_options = ['remember', Option('directory',
 
336
            help='Branch to push from, '
 
337
                 'rather than the one containing the working directory.',
 
338
            short_name='d',
 
339
            type=unicode,
 
340
            ),
 
341
            Option('no-rebase', help="Do not rebase after push.")]
281
342
 
282
 
    def run(self, location=None, remember=False, directory=None,
283
 
            no_rebase=False, strict=None):
 
343
    def run(self, location=None, remember=False, directory=None, 
 
344
            no_rebase=False):
284
345
        from bzrlib import urlutils
285
346
        from bzrlib.bzrdir import BzrDir
286
347
        from bzrlib.errors import BzrCommandError, NoWorkingTree
 
348
        from bzrlib.trace import info
287
349
        from bzrlib.workingtree import WorkingTree
288
350
 
289
351
        if directory is None:
294
356
        except NoWorkingTree:
295
357
            source_branch = Branch.open(directory)
296
358
            source_wt = None
297
 
        if source_wt is not None:
298
 
            source_wt.check_changed_or_out_of_date(
299
 
                strict, 'dpush_strict',
300
 
                more_error='Use --no-strict to force the push.',
301
 
                more_warning='Uncommitted changes will not be pushed.')
302
359
        stored_loc = source_branch.get_push_location()
303
360
        if location is None:
304
361
            if stored_loc is None:
311
368
 
312
369
        bzrdir = BzrDir.open(location)
313
370
        target_branch = bzrdir.open_branch()
 
371
        dpull = getattr(target_branch, "dpull", None)
 
372
        if dpull is None:
 
373
            raise BzrCommandError("%r is not a foreign branch, use "
 
374
                                  "regular push." % target_branch)
314
375
        target_branch.lock_write()
315
376
        try:
316
 
            try:
317
 
                push_result = source_branch.push(target_branch, lossy=True)
318
 
            except errors.LossyPushToSameVCS:
319
 
                raise BzrCommandError("%r and %r are in the same VCS, lossy "
320
 
                    "push not necessary. Please use regular push." %
321
 
                    (source_branch, target_branch))
 
377
            revid_map = dpull(source_branch)
322
378
            # We successfully created the target, remember it
323
379
            if source_branch.get_push_location() is None or remember:
324
380
                source_branch.set_push_location(target_branch.base)
329
385
                if source_wt is not None and old_last_revid != new_last_revid:
330
386
                    source_wt.lock_write()
331
387
                    try:
332
 
                        target = source_wt.branch.repository.revision_tree(
333
 
                            new_last_revid)
334
 
                        update_workingtree_fileids(source_wt, target)
 
388
                        update_workinginv_fileids(source_wt, 
 
389
                            source_wt.branch.repository.get_inventory(
 
390
                                old_last_revid),
 
391
                            source_wt.branch.repository.get_inventory(
 
392
                                new_last_revid))
335
393
                    finally:
336
394
                        source_wt.unlock()
337
 
            push_result.report(self.outf)
338
395
        finally:
339
396
            target_branch.unlock()
 
397
 
 
398