/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 bzrlib/foreign.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-02-11 04:02:41 UTC
  • mfrom: (5017.2.2 tariff)
  • Revision ID: pqm@pqm.ubuntu.com-20100211040241-w6n021dz0uus341n
(mbp) add import-tariff tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/foreign.py
1
 
# Copyright (C) 2008-2012 Canonical Ltd
 
1
# Copyright (C) 2008, 2009, 2010 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
 
17
18
"""Foreign branch utilities."""
18
19
 
19
 
from __future__ import absolute_import
20
 
 
21
 
 
22
 
from .branch import (
 
20
 
 
21
from bzrlib.branch import (
23
22
    Branch,
 
23
    InterBranch,
24
24
    )
25
 
from .repository import Repository
26
 
from .revision import Revision
27
 
from . import (
 
25
from bzrlib.commands import Command, Option
 
26
from bzrlib.repository import Repository
 
27
from bzrlib.revision import Revision
 
28
from bzrlib.lazy_import import lazy_import
 
29
lazy_import(globals(), """
 
30
from bzrlib import (
28
31
    errors,
 
32
    osutils,
29
33
    registry,
 
34
    transform,
30
35
    )
31
 
 
 
36
""")
32
37
 
33
38
class VcsMapping(object):
34
39
    """Describes the mapping between the semantics of Bazaar and a foreign VCS.
80
85
        The factory must be a callable that takes one parameter: the key.
81
86
        It must produce an instance of VcsMapping when called.
82
87
        """
83
 
        if b":" in key:
 
88
        if ":" in key:
84
89
            raise ValueError("mapping name can not contain colon (:)")
85
90
        registry.Registry.register(self, key, factory, help)
86
91
 
107
112
    """
108
113
 
109
114
    def __init__(self, foreign_revid, mapping, *args, **kwargs):
110
 
        if "inventory_sha1" not in kwargs:
111
 
            kwargs["inventory_sha1"] = b""
 
115
        if not "inventory_sha1" in kwargs:
 
116
            kwargs["inventory_sha1"] = ""
112
117
        super(ForeignRevision, self).__init__(*args, **kwargs)
113
118
        self.foreign_revid = foreign_revid
114
119
        self.mapping = mapping
136
141
        :param foreign_revid: Foreign revision id.
137
142
        :return: Dictionary mapping string keys to string values.
138
143
        """
139
 
        return {}
 
144
        return { }
140
145
 
141
146
    def serialize_foreign_revid(self, foreign_revid):
142
147
        """Serialize a foreign revision id for this VCS.
143
148
 
144
149
        :param foreign_revid: Foreign revision id
145
 
        :return: Bytestring with serialized revid, will not contain any
 
150
        :return: Bytestring with serialized revid, will not contain any 
146
151
            newlines.
147
152
        """
148
153
        raise NotImplementedError(self.serialize_foreign_revid)
174
179
        :param revid: The bzr revision id
175
180
        :return: tuple with foreign revid and vcs mapping
176
181
        """
177
 
        if b":" not in revid or b"-" not in revid:
 
182
        if not ":" in revid or not "-" in revid:
178
183
            raise errors.InvalidRevisionId(revid, None)
179
184
        try:
180
 
            foreign_vcs = self.get(revid.split(b"-")[0].decode('ascii'))
 
185
            foreign_vcs = self.get(revid.split("-")[0])
181
186
        except KeyError:
182
187
            raise errors.InvalidRevisionId(revid, None)
183
188
        return foreign_vcs.mapping_registry.revision_id_bzr_to_foreign(revid)
220
225
        """Get the default mapping for this repository."""
221
226
        raise NotImplementedError(self.get_default_mapping)
222
227
 
 
228
    def _get_inventory_xml(self, revision_id):
 
229
        """See Repository._get_inventory_xml()."""
 
230
        return self._serialise_inventory(self.get_inventory(revision_id))
 
231
 
 
232
    def get_revision_xml(self, revision_id):
 
233
        """Return the XML representation of a revision.
 
234
 
 
235
        :param revision_id: Revision for which to return the XML.
 
236
        :return: XML string
 
237
        """
 
238
        return self._serializer.write_revision_to_string(
 
239
            self.get_revision(revision_id))
 
240
 
223
241
 
224
242
class ForeignBranch(Branch):
225
243
    """Branch that exists in a foreign version control system."""
227
245
    def __init__(self, mapping):
228
246
        self.mapping = mapping
229
247
        super(ForeignBranch, self).__init__()
 
248
 
 
249
 
 
250
def update_workingtree_fileids(wt, target_tree):
 
251
    """Update the file ids in a working tree based on another tree.
 
252
 
 
253
    :param wt: Working tree in which to update file ids
 
254
    :param target_tree: Tree to retrieve new file ids from, based on path
 
255
    """
 
256
    tt = transform.TreeTransform(wt)
 
257
    try:
 
258
        for f, p, c, v, d, n, k, e in target_tree.iter_changes(wt):
 
259
            if v == (True, False):
 
260
                trans_id = tt.trans_id_tree_path(p[0])
 
261
                tt.unversion_file(trans_id)
 
262
            elif v == (False, True):
 
263
                trans_id = tt.trans_id_tree_path(p[1])
 
264
                tt.version_file(f, trans_id)
 
265
        tt.apply()
 
266
    finally:
 
267
        tt.finalize()
 
268
    if len(wt.get_parent_ids()) == 1:
 
269
        wt.set_parent_trees([(target_tree.get_revision_id(), target_tree)])
 
270
    else:
 
271
        wt.set_last_revision(target_tree.get_revision_id())
 
272
 
 
273
 
 
274
class cmd_dpush(Command):
 
275
    """Push into a different VCS without any custom bzr metadata.
 
276
 
 
277
    This will afterwards rebase the local branch on the remote
 
278
    branch unless the --no-rebase option is used, in which case 
 
279
    the two branches will be out of sync after the push. 
 
280
    """
 
281
    hidden = True
 
282
    takes_args = ['location?']
 
283
    takes_options = [
 
284
        'remember',
 
285
        Option('directory',
 
286
               help='Branch to push from, '
 
287
               'rather than the one containing the working directory.',
 
288
               short_name='d',
 
289
               type=unicode,
 
290
               ),
 
291
        Option('no-rebase', help="Do not rebase after push."),
 
292
        Option('strict',
 
293
               help='Refuse to push if there are uncommitted changes in'
 
294
               ' the working tree, --no-strict disables the check.'),
 
295
        ]
 
296
 
 
297
    def run(self, location=None, remember=False, directory=None,
 
298
            no_rebase=False, strict=None):
 
299
        from bzrlib import urlutils
 
300
        from bzrlib.bzrdir import BzrDir
 
301
        from bzrlib.errors import BzrCommandError, NoWorkingTree
 
302
        from bzrlib.workingtree import WorkingTree
 
303
 
 
304
        if directory is None:
 
305
            directory = "."
 
306
        try:
 
307
            source_wt = WorkingTree.open_containing(directory)[0]
 
308
            source_branch = source_wt.branch
 
309
        except NoWorkingTree:
 
310
            source_branch = Branch.open(directory)
 
311
            source_wt = None
 
312
        if strict is None:
 
313
            strict = source_branch.get_config(
 
314
                ).get_user_option_as_bool('dpush_strict')
 
315
        if strict is None: strict = True # default value
 
316
        if strict and source_wt is not None:
 
317
            if (source_wt.has_changes()):
 
318
                raise errors.UncommittedChanges(
 
319
                    source_wt, more='Use --no-strict to force the push.')
 
320
            if source_wt.last_revision() != source_wt.branch.last_revision():
 
321
                # The tree has lost sync with its branch, there is little
 
322
                # chance that the user is aware of it but he can still force
 
323
                # the push with --no-strict
 
324
                raise errors.OutOfDateTree(
 
325
                    source_wt, more='Use --no-strict to force the push.')
 
326
        stored_loc = source_branch.get_push_location()
 
327
        if location is None:
 
328
            if stored_loc is None:
 
329
                raise BzrCommandError("No push location known or specified.")
 
330
            else:
 
331
                display_url = urlutils.unescape_for_display(stored_loc,
 
332
                        self.outf.encoding)
 
333
                self.outf.write("Using saved location: %s\n" % display_url)
 
334
                location = stored_loc
 
335
 
 
336
        bzrdir = BzrDir.open(location)
 
337
        target_branch = bzrdir.open_branch()
 
338
        target_branch.lock_write()
 
339
        try:
 
340
            try:
 
341
                push_result = source_branch.lossy_push(target_branch)
 
342
            except errors.LossyPushToSameVCS:
 
343
                raise BzrCommandError("%r and %r are in the same VCS, lossy "
 
344
                    "push not necessary. Please use regular push." %
 
345
                    (source_branch, target_branch))
 
346
            # We successfully created the target, remember it
 
347
            if source_branch.get_push_location() is None or remember:
 
348
                source_branch.set_push_location(target_branch.base)
 
349
            if not no_rebase:
 
350
                old_last_revid = source_branch.last_revision()
 
351
                source_branch.pull(target_branch, overwrite=True)
 
352
                new_last_revid = source_branch.last_revision()
 
353
                if source_wt is not None and old_last_revid != new_last_revid:
 
354
                    source_wt.lock_write()
 
355
                    try:
 
356
                        target = source_wt.branch.repository.revision_tree(
 
357
                            new_last_revid)
 
358
                        update_workingtree_fileids(source_wt, target)
 
359
                    finally:
 
360
                        source_wt.unlock()
 
361
            push_result.report(self.outf)
 
362
        finally:
 
363
            target_branch.unlock()
 
364
 
 
365
 
 
366
class InterToForeignBranch(InterBranch):
 
367
 
 
368
    def lossy_push(self, stop_revision=None):
 
369
        """Push deltas into another branch.
 
370
 
 
371
        :note: This does not, like push, retain the revision ids from 
 
372
            the source branch and will, rather than adding bzr-specific 
 
373
            metadata, push only those semantics of the revision that can be 
 
374
            natively represented by this branch' VCS.
 
375
 
 
376
        :param target: Target branch
 
377
        :param stop_revision: Revision to push, defaults to last revision.
 
378
        :return: BranchPushResult with an extra member revidmap: 
 
379
            A dictionary mapping revision ids from the target branch 
 
380
            to new revision ids in the target branch, for each 
 
381
            revision that was pushed.
 
382
        """
 
383
        raise NotImplementedError(self.lossy_push)