← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/foreign.py

  • Committer: Ian Clatworthy
  • Date: 2009-04-03 02:29:30 UTC
  • mto: This revision was merged to the branch mainline in revision 4259.
  • Revision ID: ian.clatworthy@canonical.com-20090403022930-epud0dn5421fp0a0
chk_map code from brisbane-core

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/foreign.py
18
18
"""Foreign branch utilities."""
19
19
 
20
20
 
21
 
from bzrlib.branch import (
22
 
    Branch,
23
 
    InterBranch,
24
 
    )
 
21
from bzrlib.branch import Branch
25
22
from bzrlib.commands import Command, Option
26
23
from bzrlib.repository import Repository
27
24
from bzrlib.revision import Revision
31
28
    errors,
32
29
    osutils,
33
30
    registry,
34
 
    transform,
35
31
    )
36
32
""")
37
33
 
45
41
    # Whether this mapping supports exporting and importing all bzr semantics.
46
42
    roundtripping = False
47
43
 
48
 
    # Prefix used when importing revisions native to the foreign VCS (as
49
 
    # opposed to roundtripping bzr-native revisions) using this mapping.
 
44
    # Prefix used when importing native foreign revisions (not roundtripped)
 
45
    # using this mapping.
50
46
    revid_prefix = None
51
47
 
52
48
    def __init__(self, vcs):
119
115
        self.mapping = mapping
120
116
 
121
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
 
122
137
class ForeignVcs(object):
123
138
    """A foreign version control system."""
124
139
 
160
175
        :param revid: The bzr revision id
161
176
        :return: tuple with foreign revid and vcs mapping
162
177
        """
163
 
        if not ":" in revid or not "-" in revid:
 
178
        if not "-" in revid:
164
179
            raise errors.InvalidRevisionId(revid, None)
165
180
        try:
166
181
            foreign_vcs = self.get(revid.split("-")[0])
230
245
            self.get_revision(revision_id))
231
246
 
232
247
 
233
 
class ForeignBranch(Branch):
234
 
    """Branch that exists in a foreign version control system."""
235
 
 
236
 
    def __init__(self, mapping):
237
 
        self.mapping = mapping
238
 
        super(ForeignBranch, self).__init__()
239
 
 
240
 
 
241
 
def update_workingtree_fileids(wt, target_tree):
242
 
    """Update the file ids in a working tree based on another tree.
243
 
 
244
 
    :param wt: Working tree in which to update file ids
245
 
    :param target_tree: Tree to retrieve new file ids from, based on path
246
 
    """
247
 
    tt = transform.TreeTransform(wt)
248
 
    try:
249
 
        for f, p, c, v, d, n, k, e in target_tree.iter_changes(wt):
250
 
            if v == (True, False):
251
 
                trans_id = tt.trans_id_tree_path(p[0])
252
 
                tt.unversion_file(trans_id)
253
 
            elif v == (False, True):
254
 
                trans_id = tt.trans_id_tree_path(p[1])
255
 
                tt.version_file(f, trans_id)
256
 
        tt.apply()
257
 
    finally:
258
 
        tt.finalize()
259
 
    if len(wt.get_parent_ids()) == 1:
260
 
        wt.set_parent_trees([(target_tree.get_revision_id(), target_tree)])
261
 
    else:
262
 
        wt.set_last_revision(target_tree.get_revision_id())
263
 
 
264
 
 
265
 
class cmd_dpush(Command):
266
 
    """Push into a different VCS without any custom bzr metadata.
267
 
 
268
 
    This will afterwards rebase the local branch on the remote
269
 
    branch unless the --no-rebase option is used, in which case 
270
 
    the two branches will be out of sync after the push. 
271
 
    """
272
 
    hidden = True
273
 
    takes_args = ['location?']
274
 
    takes_options = ['remember', Option('directory',
275
 
            help='Branch to push from, '
276
 
                 'rather than the one containing the working directory.',
277
 
            short_name='d',
278
 
            type=unicode,
279
 
            ),
280
 
            Option('no-rebase', help="Do not rebase after push.")]
281
 
 
282
 
    def run(self, location=None, remember=False, directory=None, 
283
 
            no_rebase=False):
284
 
        from bzrlib import urlutils
285
 
        from bzrlib.bzrdir import BzrDir
286
 
        from bzrlib.errors import BzrCommandError, NoWorkingTree
287
 
        from bzrlib.trace import info
288
 
        from bzrlib.workingtree import WorkingTree
289
 
 
290
 
        if directory is None:
291
 
            directory = "."
292
 
        try:
293
 
            source_wt = WorkingTree.open_containing(directory)[0]
294
 
            source_branch = source_wt.branch
295
 
        except NoWorkingTree:
296
 
            source_branch = Branch.open(directory)
297
 
            source_wt = None
298
 
        stored_loc = source_branch.get_push_location()
299
 
        if location is None:
300
 
            if stored_loc is None:
301
 
                raise BzrCommandError("No push location known or specified.")
302
 
            else:
303
 
                display_url = urlutils.unescape_for_display(stored_loc,
304
 
                        self.outf.encoding)
305
 
                self.outf.write("Using saved location: %s\n" % display_url)
306
 
                location = stored_loc
307
 
 
308
 
        bzrdir = BzrDir.open(location)
309
 
        target_branch = bzrdir.open_branch()
310
 
        target_branch.lock_write()
311
 
        try:
312
 
            try:
313
 
                push_result = source_branch.lossy_push(target_branch)
314
 
            except errors.LossyPushToSameVCS:
315
 
                raise BzrCommandError("%r and %r are in the same VCS, lossy "
316
 
                    "push not necessary. Please use regular push." %
317
 
                    (source_branch, target_branch))
318
 
            # We successfully created the target, remember it
319
 
            if source_branch.get_push_location() is None or remember:
320
 
                source_branch.set_push_location(target_branch.base)
321
 
            if not no_rebase:
322
 
                old_last_revid = source_branch.last_revision()
323
 
                source_branch.pull(target_branch, overwrite=True)
324
 
                new_last_revid = source_branch.last_revision()
325
 
                if source_wt is not None and old_last_revid != new_last_revid:
326
 
                    source_wt.lock_write()
327
 
                    try:
328
 
                        target = source_wt.branch.repository.revision_tree(
329
 
                            new_last_revid)
330
 
                        update_workingtree_fileids(source_wt, target)
331
 
                    finally:
332
 
                        source_wt.unlock()
333
 
            push_result.report(self.outf)
334
 
        finally:
335
 
            target_branch.unlock()
336
 
 
337
 
 
338
 
class InterToForeignBranch(InterBranch):
339
 
 
340
 
    def lossy_push(self, stop_revision=None):
341
 
        """Push deltas into another branch.
342
 
 
343
 
        :note: This does not, like push, retain the revision ids from 
344
 
            the source branch and will, rather than adding bzr-specific 
345
 
            metadata, push only those semantics of the revision that can be 
346
 
            natively represented by this branch' VCS.
347
 
 
348
 
        :param target: Target branch
349
 
        :param stop_revision: Revision to push, defaults to last revision.
350
 
        :return: BranchPushResult with an extra member revidmap: 
351
 
            A dictionary mapping revision ids from the target branch 
352
 
            to new revision ids in the target branch, for each 
353
 
            revision that was pushed.
354
 
        """
355
 
        raise NotImplementedError(self.lossy_push)