← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/foreign.py

  • Committer: Martin Pool
  • Date: 2009-08-11 02:58:23 UTC
  • mfrom: (4595.3.1 1.18)
  • mto: This revision was merged to the branch mainline in revision 4597.
  • Revision ID: mbp@sourcefrog.net-20090811025823-aa20gm1shxe2nmd7
Merge back 1.18 and update NEWS

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 Branch
 
21
from bzrlib.branch import (
 
22
    Branch,
 
23
    InterBranch,
 
24
    )
22
25
from bzrlib.commands import Command, Option
23
26
from bzrlib.repository import Repository
24
27
from bzrlib.revision import Revision
28
31
    errors,
29
32
    osutils,
30
33
    registry,
 
34
    transform,
31
35
    )
32
36
""")
33
37
 
41
45
    # Whether this mapping supports exporting and importing all bzr semantics.
42
46
    roundtripping = False
43
47
 
44
 
    # Prefix used when importing native foreign revisions (not roundtripped)
45
 
    # using this mapping.
 
48
    # Prefix used when importing revisions native to the foreign VCS (as
 
49
    # opposed to roundtripping bzr-native revisions) using this mapping.
46
50
    revid_prefix = None
47
51
 
48
52
    def __init__(self, vcs):
115
119
        self.mapping = mapping
116
120
 
117
121
 
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
 
 
137
122
class ForeignVcs(object):
138
123
    """A foreign version control system."""
139
124
 
175
160
        :param revid: The bzr revision id
176
161
        :return: tuple with foreign revid and vcs mapping
177
162
        """
178
 
        if not "-" in revid:
 
163
        if not ":" in revid or not "-" in revid:
179
164
            raise errors.InvalidRevisionId(revid, None)
180
165
        try:
181
166
            foreign_vcs = self.get(revid.split("-")[0])
245
230
            self.get_revision(revision_id))
246
231
 
247
232
 
 
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)