← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/foreign.py

  • Committer: Andrew Bennetts
  • Date: 2010-06-25 06:47:40 UTC
  • mto: (5050.3.16 2.2)
  • mto: This revision was merged to the branch mainline in revision 5365.
  • Revision ID: andrew.bennetts@canonical.com-20100625064740-k93ngat248kdcqdm
Remove merge_into_helper for now, as it currently has no callers.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/foreign.py
1
 
# Copyright (C) 2008 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
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
 
34
38
class VcsMapping(object):
35
 
    """Describes the mapping between the semantics of Bazaar and a foreign vcs.
 
39
    """Describes the mapping between the semantics of Bazaar and a foreign VCS.
36
40
 
37
41
    """
38
42
    # Whether this is an experimental mapping that is still open to changes.
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):
71
75
 
72
76
class VcsMappingRegistry(registry.Registry):
73
77
    """Registry for Bazaar<->foreign VCS mappings.
74
 
    
 
78
 
75
79
    There should be one instance of this registry for every foreign VCS.
76
80
    """
77
81
 
102
106
 
103
107
 
104
108
class ForeignRevision(Revision):
105
 
    """A Revision from a Foreign repository. Remembers 
 
109
    """A Revision from a Foreign repository. Remembers
106
110
    information about foreign revision id and mapping.
107
111
 
108
112
    """
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
 
140
 
    def __init__(self, mapping_registry):
 
125
    branch_format = None
 
126
 
 
127
    repository_format = None
 
128
 
 
129
    def __init__(self, mapping_registry, abbreviation=None):
 
130
        """Create a new foreign vcs instance.
 
131
 
 
132
        :param mapping_registry: Registry with mappings for this VCS.
 
133
        :param abbreviation: Optional abbreviation ('bzr', 'svn', 'git', etc)
 
134
        """
 
135
        self.abbreviation = abbreviation
141
136
        self.mapping_registry = mapping_registry
142
137
 
143
138
    def show_foreign_revid(self, foreign_revid):
144
139
        """Prepare a foreign revision id for formatting using bzr log.
145
 
        
 
140
 
146
141
        :param foreign_revid: Foreign revision id.
147
142
        :return: Dictionary mapping string keys to string values.
148
143
        """
149
144
        return { }
150
145
 
 
146
    def serialize_foreign_revid(self, foreign_revid):
 
147
        """Serialize a foreign revision id for this VCS.
 
148
 
 
149
        :param foreign_revid: Foreign revision id
 
150
        :return: Bytestring with serialized revid, will not contain any 
 
151
            newlines.
 
152
        """
 
153
        raise NotImplementedError(self.serialize_foreign_revid)
 
154
 
151
155
 
152
156
class ForeignVcsRegistry(registry.Registry):
153
157
    """Registry for Foreign VCSes.
154
158
 
155
 
    There should be one entry per foreign VCS. Example entries would be 
 
159
    There should be one entry per foreign VCS. Example entries would be
156
160
    "git", "svn", "hg", "darcs", etc.
157
 
    
 
161
 
158
162
    """
159
163
 
160
164
    def register(self, key, foreign_vcs, help):
169
173
        registry.Registry.register(self, key, foreign_vcs, help)
170
174
 
171
175
    def parse_revision_id(self, revid):
172
 
        """Parse a bzr revision and return the matching mapping and foreign 
 
176
        """Parse a bzr revision and return the matching mapping and foreign
173
177
        revid.
174
 
        
 
178
 
175
179
        :param revid: The bzr revision id
176
180
        :return: tuple with foreign revid and vcs mapping
177
181
        """
178
 
        if not "-" in revid:
 
182
        if not ":" in revid or not "-" in revid:
179
183
            raise errors.InvalidRevisionId(revid, None)
180
184
        try:
181
185
            foreign_vcs = self.get(revid.split("-")[0])
190
194
class ForeignRepository(Repository):
191
195
    """A Repository that exists in a foreign version control system.
192
196
 
193
 
    The data in this repository can not be represented natively using 
 
197
    The data in this repository can not be represented natively using
194
198
    Bazaars internal datastructures, but have to converted using a VcsMapping.
195
199
    """
196
200
 
200
204
    def has_foreign_revision(self, foreign_revid):
201
205
        """Check whether the specified foreign revision is present.
202
206
 
203
 
        :param foreign_revid: A foreign revision id, in the format used 
 
207
        :param foreign_revid: A foreign revision id, in the format used
204
208
                              by this Repository's VCS.
205
209
        """
206
210
        raise NotImplementedError(self.has_foreign_revision)
221
225
        """Get the default mapping for this repository."""
222
226
        raise NotImplementedError(self.get_default_mapping)
223
227
 
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
 
 
247
 
 
 
228
 
 
229
class ForeignBranch(Branch):
 
230
    """Branch that exists in a foreign version control system."""
 
231
 
 
232
    def __init__(self, mapping):
 
233
        self.mapping = mapping
 
234
        super(ForeignBranch, self).__init__()
 
235
 
 
236
 
 
237
def update_workingtree_fileids(wt, target_tree):
 
238
    """Update the file ids in a working tree based on another tree.
 
239
 
 
240
    :param wt: Working tree in which to update file ids
 
241
    :param target_tree: Tree to retrieve new file ids from, based on path
 
242
    """
 
243
    tt = transform.TreeTransform(wt)
 
244
    try:
 
245
        for f, p, c, v, d, n, k, e in target_tree.iter_changes(wt):
 
246
            if v == (True, False):
 
247
                trans_id = tt.trans_id_tree_path(p[0])
 
248
                tt.unversion_file(trans_id)
 
249
            elif v == (False, True):
 
250
                trans_id = tt.trans_id_tree_path(p[1])
 
251
                tt.version_file(f, trans_id)
 
252
        tt.apply()
 
253
    finally:
 
254
        tt.finalize()
 
255
    if len(wt.get_parent_ids()) == 1:
 
256
        wt.set_parent_trees([(target_tree.get_revision_id(), target_tree)])
 
257
    else:
 
258
        wt.set_last_revision(target_tree.get_revision_id())
 
259
 
 
260
 
 
261
class cmd_dpush(Command):
 
262
    __doc__ = """Push into a different VCS without any custom bzr metadata.
 
263
 
 
264
    This will afterwards rebase the local branch on the remote
 
265
    branch unless the --no-rebase option is used, in which case 
 
266
    the two branches will be out of sync after the push. 
 
267
    """
 
268
    hidden = True
 
269
    takes_args = ['location?']
 
270
    takes_options = [
 
271
        'remember',
 
272
        Option('directory',
 
273
               help='Branch to push from, '
 
274
               'rather than the one containing the working directory.',
 
275
               short_name='d',
 
276
               type=unicode,
 
277
               ),
 
278
        Option('no-rebase', help="Do not rebase after push."),
 
279
        Option('strict',
 
280
               help='Refuse to push if there are uncommitted changes in'
 
281
               ' the working tree, --no-strict disables the check.'),
 
282
        ]
 
283
 
 
284
    def run(self, location=None, remember=False, directory=None,
 
285
            no_rebase=False, strict=None):
 
286
        from bzrlib import urlutils
 
287
        from bzrlib.bzrdir import BzrDir
 
288
        from bzrlib.errors import BzrCommandError, NoWorkingTree
 
289
        from bzrlib.workingtree import WorkingTree
 
290
 
 
291
        if directory is None:
 
292
            directory = "."
 
293
        try:
 
294
            source_wt = WorkingTree.open_containing(directory)[0]
 
295
            source_branch = source_wt.branch
 
296
        except NoWorkingTree:
 
297
            source_branch = Branch.open(directory)
 
298
            source_wt = None
 
299
        if source_wt is not None:
 
300
            source_wt.check_changed_or_out_of_date(
 
301
                strict, 'dpush_strict',
 
302
                more_error='Use --no-strict to force the push.',
 
303
                more_warning='Uncommitted changes will not be pushed.')
 
304
        stored_loc = source_branch.get_push_location()
 
305
        if location is None:
 
306
            if stored_loc is None:
 
307
                raise BzrCommandError("No push location known or specified.")
 
308
            else:
 
309
                display_url = urlutils.unescape_for_display(stored_loc,
 
310
                        self.outf.encoding)
 
311
                self.outf.write("Using saved location: %s\n" % display_url)
 
312
                location = stored_loc
 
313
 
 
314
        bzrdir = BzrDir.open(location)
 
315
        target_branch = bzrdir.open_branch()
 
316
        target_branch.lock_write()
 
317
        try:
 
318
            try:
 
319
                push_result = source_branch.lossy_push(target_branch)
 
320
            except errors.LossyPushToSameVCS:
 
321
                raise BzrCommandError("%r and %r are in the same VCS, lossy "
 
322
                    "push not necessary. Please use regular push." %
 
323
                    (source_branch, target_branch))
 
324
            # We successfully created the target, remember it
 
325
            if source_branch.get_push_location() is None or remember:
 
326
                source_branch.set_push_location(target_branch.base)
 
327
            if not no_rebase:
 
328
                old_last_revid = source_branch.last_revision()
 
329
                source_branch.pull(target_branch, overwrite=True)
 
330
                new_last_revid = source_branch.last_revision()
 
331
                if source_wt is not None and old_last_revid != new_last_revid:
 
332
                    source_wt.lock_write()
 
333
                    try:
 
334
                        target = source_wt.branch.repository.revision_tree(
 
335
                            new_last_revid)
 
336
                        update_workingtree_fileids(source_wt, target)
 
337
                    finally:
 
338
                        source_wt.unlock()
 
339
            push_result.report(self.outf)
 
340
        finally:
 
341
            target_branch.unlock()
 
342
 
 
343
 
 
344
class InterToForeignBranch(InterBranch):
 
345
 
 
346
    def lossy_push(self, stop_revision=None):
 
347
        """Push deltas into another branch.
 
348
 
 
349
        :note: This does not, like push, retain the revision ids from 
 
350
            the source branch and will, rather than adding bzr-specific 
 
351
            metadata, push only those semantics of the revision that can be 
 
352
            natively represented by this branch' VCS.
 
353
 
 
354
        :param target: Target branch
 
355
        :param stop_revision: Revision to push, defaults to last revision.
 
356
        :return: BranchPushResult with an extra member revidmap: 
 
357
            A dictionary mapping revision ids from the target branch 
 
358
            to new revision ids in the target branch, for each 
 
359
            revision that was pushed.
 
360
        """
 
361
        raise NotImplementedError(self.lossy_push)