← 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-01-12 03:53:21 UTC
  • mfrom: (4948 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4964.
  • Revision ID: andrew.bennetts@canonical.com-20100112035321-hofpz5p10224ryj3
Merge lp:bzr, resolving conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/foreign.py
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)
228
232
    def get_inventory_sha1(self, revision_id):
229
233
        """Get the sha1 for the XML representation of an inventory.
230
234
 
231
 
        :param revision_id: Revision id of the inventory for which to return 
 
235
        :param revision_id: Revision id of the inventory for which to return
232
236
         the SHA1.
233
237
        :return: XML string
234
238
        """
245
249
            self.get_revision(revision_id))
246
250
 
247
251
 
 
252
class ForeignBranch(Branch):
 
253
    """Branch that exists in a foreign version control system."""
 
254
 
 
255
    def __init__(self, mapping):
 
256
        self.mapping = mapping
 
257
        super(ForeignBranch, self).__init__()
 
258
 
 
259
 
 
260
def update_workingtree_fileids(wt, target_tree):
 
261
    """Update the file ids in a working tree based on another tree.
 
262
 
 
263
    :param wt: Working tree in which to update file ids
 
264
    :param target_tree: Tree to retrieve new file ids from, based on path
 
265
    """
 
266
    tt = transform.TreeTransform(wt)
 
267
    try:
 
268
        for f, p, c, v, d, n, k, e in target_tree.iter_changes(wt):
 
269
            if v == (True, False):
 
270
                trans_id = tt.trans_id_tree_path(p[0])
 
271
                tt.unversion_file(trans_id)
 
272
            elif v == (False, True):
 
273
                trans_id = tt.trans_id_tree_path(p[1])
 
274
                tt.version_file(f, trans_id)
 
275
        tt.apply()
 
276
    finally:
 
277
        tt.finalize()
 
278
    if len(wt.get_parent_ids()) == 1:
 
279
        wt.set_parent_trees([(target_tree.get_revision_id(), target_tree)])
 
280
    else:
 
281
        wt.set_last_revision(target_tree.get_revision_id())
 
282
 
 
283
 
 
284
class cmd_dpush(Command):
 
285
    """Push into a different VCS without any custom bzr metadata.
 
286
 
 
287
    This will afterwards rebase the local branch on the remote
 
288
    branch unless the --no-rebase option is used, in which case 
 
289
    the two branches will be out of sync after the push. 
 
290
    """
 
291
    hidden = True
 
292
    takes_args = ['location?']
 
293
    takes_options = [
 
294
        'remember',
 
295
        Option('directory',
 
296
               help='Branch to push from, '
 
297
               'rather than the one containing the working directory.',
 
298
               short_name='d',
 
299
               type=unicode,
 
300
               ),
 
301
        Option('no-rebase', help="Do not rebase after push."),
 
302
        Option('strict',
 
303
               help='Refuse to push if there are uncommitted changes in'
 
304
               ' the working tree, --no-strict disables the check.'),
 
305
        ]
 
306
 
 
307
    def run(self, location=None, remember=False, directory=None,
 
308
            no_rebase=False, strict=None):
 
309
        from bzrlib import urlutils
 
310
        from bzrlib.bzrdir import BzrDir
 
311
        from bzrlib.errors import BzrCommandError, NoWorkingTree
 
312
        from bzrlib.workingtree import WorkingTree
 
313
 
 
314
        if directory is None:
 
315
            directory = "."
 
316
        try:
 
317
            source_wt = WorkingTree.open_containing(directory)[0]
 
318
            source_branch = source_wt.branch
 
319
        except NoWorkingTree:
 
320
            source_branch = Branch.open(directory)
 
321
            source_wt = None
 
322
        if strict is None:
 
323
            strict = source_branch.get_config(
 
324
                ).get_user_option_as_bool('dpush_strict')
 
325
        if strict is None: strict = True # default value
 
326
        if strict and source_wt is not None:
 
327
            if (source_wt.has_changes()):
 
328
                raise errors.UncommittedChanges(
 
329
                    source_wt, more='Use --no-strict to force the push.')
 
330
            if source_wt.last_revision() != source_wt.branch.last_revision():
 
331
                # The tree has lost sync with its branch, there is little
 
332
                # chance that the user is aware of it but he can still force
 
333
                # the push with --no-strict
 
334
                raise errors.OutOfDateTree(
 
335
                    source_wt, more='Use --no-strict to force the push.')
 
336
        stored_loc = source_branch.get_push_location()
 
337
        if location is None:
 
338
            if stored_loc is None:
 
339
                raise BzrCommandError("No push location known or specified.")
 
340
            else:
 
341
                display_url = urlutils.unescape_for_display(stored_loc,
 
342
                        self.outf.encoding)
 
343
                self.outf.write("Using saved location: %s\n" % display_url)
 
344
                location = stored_loc
 
345
 
 
346
        bzrdir = BzrDir.open(location)
 
347
        target_branch = bzrdir.open_branch()
 
348
        target_branch.lock_write()
 
349
        try:
 
350
            try:
 
351
                push_result = source_branch.lossy_push(target_branch)
 
352
            except errors.LossyPushToSameVCS:
 
353
                raise BzrCommandError("%r and %r are in the same VCS, lossy "
 
354
                    "push not necessary. Please use regular push." %
 
355
                    (source_branch, target_branch))
 
356
            # We successfully created the target, remember it
 
357
            if source_branch.get_push_location() is None or remember:
 
358
                source_branch.set_push_location(target_branch.base)
 
359
            if not no_rebase:
 
360
                old_last_revid = source_branch.last_revision()
 
361
                source_branch.pull(target_branch, overwrite=True)
 
362
                new_last_revid = source_branch.last_revision()
 
363
                if source_wt is not None and old_last_revid != new_last_revid:
 
364
                    source_wt.lock_write()
 
365
                    try:
 
366
                        target = source_wt.branch.repository.revision_tree(
 
367
                            new_last_revid)
 
368
                        update_workingtree_fileids(source_wt, target)
 
369
                    finally:
 
370
                        source_wt.unlock()
 
371
            push_result.report(self.outf)
 
372
        finally:
 
373
            target_branch.unlock()
 
374
 
 
375
 
 
376
class InterToForeignBranch(InterBranch):
 
377
 
 
378
    def lossy_push(self, stop_revision=None):
 
379
        """Push deltas into another branch.
 
380
 
 
381
        :note: This does not, like push, retain the revision ids from 
 
382
            the source branch and will, rather than adding bzr-specific 
 
383
            metadata, push only those semantics of the revision that can be 
 
384
            natively represented by this branch' VCS.
 
385
 
 
386
        :param target: Target branch
 
387
        :param stop_revision: Revision to push, defaults to last revision.
 
388
        :return: BranchPushResult with an extra member revidmap: 
 
389
            A dictionary mapping revision ids from the target branch 
 
390
            to new revision ids in the target branch, for each 
 
391
            revision that was pushed.
 
392
        """
 
393
        raise NotImplementedError(self.lossy_push)