~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/foreign.py

  • Committer: Mark Hammond
  • Date: 2008-08-10 11:16:39 UTC
  • mto: (3606.5.3 1.6)
  • mto: This revision was merged to the branch mainline in revision 3626.
  • Revision ID: mhammond@skippinet.com.au-20080810111639-9upz1wig1s8lvz62
install all files with 'restartreplace uninsrestartdelete' and close
tbzrcache at uninstall time.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2008 Canonical Ltd
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
 
18
 
"""Foreign branch utilities."""
19
 
 
20
 
 
21
 
from bzrlib.branch import (
22
 
    Branch,
23
 
    InterBranch,
24
 
    )
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 (
31
 
    errors,
32
 
    osutils,
33
 
    registry,
34
 
    transform,
35
 
    )
36
 
""")
37
 
 
38
 
class VcsMapping(object):
39
 
    """Describes the mapping between the semantics of Bazaar and a foreign VCS.
40
 
 
41
 
    """
42
 
    # Whether this is an experimental mapping that is still open to changes.
43
 
    experimental = False
44
 
 
45
 
    # Whether this mapping supports exporting and importing all bzr semantics.
46
 
    roundtripping = False
47
 
 
48
 
    # Prefix used when importing revisions native to the foreign VCS (as
49
 
    # opposed to roundtripping bzr-native revisions) using this mapping.
50
 
    revid_prefix = None
51
 
 
52
 
    def __init__(self, vcs):
53
 
        """Create a new VcsMapping.
54
 
 
55
 
        :param vcs: VCS that this mapping maps to Bazaar
56
 
        """
57
 
        self.vcs = vcs
58
 
 
59
 
    def revision_id_bzr_to_foreign(self, bzr_revid):
60
 
        """Parse a bzr revision id and convert it to a foreign revid.
61
 
 
62
 
        :param bzr_revid: The bzr revision id (a string).
63
 
        :return: A foreign revision id, can be any sort of object.
64
 
        """
65
 
        raise NotImplementedError(self.revision_id_bzr_to_foreign)
66
 
 
67
 
    def revision_id_foreign_to_bzr(self, foreign_revid):
68
 
        """Parse a foreign revision id and convert it to a bzr revid.
69
 
 
70
 
        :param foreign_revid: Foreign revision id, can be any sort of object.
71
 
        :return: A bzr revision id.
72
 
        """
73
 
        raise NotImplementedError(self.revision_id_foreign_to_bzr)
74
 
 
75
 
 
76
 
class VcsMappingRegistry(registry.Registry):
77
 
    """Registry for Bazaar<->foreign VCS mappings.
78
 
 
79
 
    There should be one instance of this registry for every foreign VCS.
80
 
    """
81
 
 
82
 
    def register(self, key, factory, help):
83
 
        """Register a mapping between Bazaar and foreign VCS semantics.
84
 
 
85
 
        The factory must be a callable that takes one parameter: the key.
86
 
        It must produce an instance of VcsMapping when called.
87
 
        """
88
 
        if ":" in key:
89
 
            raise ValueError("mapping name can not contain colon (:)")
90
 
        registry.Registry.register(self, key, factory, help)
91
 
 
92
 
    def set_default(self, key):
93
 
        """Set the 'default' key to be a clone of the supplied key.
94
 
 
95
 
        This method must be called once and only once.
96
 
        """
97
 
        self._set_default_key(key)
98
 
 
99
 
    def get_default(self):
100
 
        """Convenience function for obtaining the default mapping to use."""
101
 
        return self.get(self._get_default_key())
102
 
 
103
 
    def revision_id_bzr_to_foreign(self, revid):
104
 
        """Convert a bzr revision id to a foreign revid."""
105
 
        raise NotImplementedError(self.revision_id_bzr_to_foreign)
106
 
 
107
 
 
108
 
class ForeignRevision(Revision):
109
 
    """A Revision from a Foreign repository. Remembers
110
 
    information about foreign revision id and mapping.
111
 
 
112
 
    """
113
 
 
114
 
    def __init__(self, foreign_revid, mapping, *args, **kwargs):
115
 
        if not "inventory_sha1" in kwargs:
116
 
            kwargs["inventory_sha1"] = ""
117
 
        super(ForeignRevision, self).__init__(*args, **kwargs)
118
 
        self.foreign_revid = foreign_revid
119
 
        self.mapping = mapping
120
 
 
121
 
 
122
 
class ForeignVcs(object):
123
 
    """A foreign version control system."""
124
 
 
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
136
 
        self.mapping_registry = mapping_registry
137
 
 
138
 
    def show_foreign_revid(self, foreign_revid):
139
 
        """Prepare a foreign revision id for formatting using bzr log.
140
 
 
141
 
        :param foreign_revid: Foreign revision id.
142
 
        :return: Dictionary mapping string keys to string values.
143
 
        """
144
 
        return { }
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
 
 
155
 
 
156
 
class ForeignVcsRegistry(registry.Registry):
157
 
    """Registry for Foreign VCSes.
158
 
 
159
 
    There should be one entry per foreign VCS. Example entries would be
160
 
    "git", "svn", "hg", "darcs", etc.
161
 
 
162
 
    """
163
 
 
164
 
    def register(self, key, foreign_vcs, help):
165
 
        """Register a foreign VCS.
166
 
 
167
 
        :param key: Prefix of the foreign VCS in revision ids
168
 
        :param foreign_vcs: ForeignVCS instance
169
 
        :param help: Description of the foreign VCS
170
 
        """
171
 
        if ":" in key or "-" in key:
172
 
            raise ValueError("vcs name can not contain : or -")
173
 
        registry.Registry.register(self, key, foreign_vcs, help)
174
 
 
175
 
    def parse_revision_id(self, revid):
176
 
        """Parse a bzr revision and return the matching mapping and foreign
177
 
        revid.
178
 
 
179
 
        :param revid: The bzr revision id
180
 
        :return: tuple with foreign revid and vcs mapping
181
 
        """
182
 
        if not ":" in revid or not "-" in revid:
183
 
            raise errors.InvalidRevisionId(revid, None)
184
 
        try:
185
 
            foreign_vcs = self.get(revid.split("-")[0])
186
 
        except KeyError:
187
 
            raise errors.InvalidRevisionId(revid, None)
188
 
        return foreign_vcs.mapping_registry.revision_id_bzr_to_foreign(revid)
189
 
 
190
 
 
191
 
foreign_vcs_registry = ForeignVcsRegistry()
192
 
 
193
 
 
194
 
class ForeignRepository(Repository):
195
 
    """A Repository that exists in a foreign version control system.
196
 
 
197
 
    The data in this repository can not be represented natively using
198
 
    Bazaars internal datastructures, but have to converted using a VcsMapping.
199
 
    """
200
 
 
201
 
    # This repository's native version control system
202
 
    vcs = None
203
 
 
204
 
    def has_foreign_revision(self, foreign_revid):
205
 
        """Check whether the specified foreign revision is present.
206
 
 
207
 
        :param foreign_revid: A foreign revision id, in the format used
208
 
                              by this Repository's VCS.
209
 
        """
210
 
        raise NotImplementedError(self.has_foreign_revision)
211
 
 
212
 
    def lookup_bzr_revision_id(self, revid):
213
 
        """Lookup a mapped or roundtripped revision by revision id.
214
 
 
215
 
        :param revid: Bazaar revision id
216
 
        :return: Tuple with foreign revision id and mapping.
217
 
        """
218
 
        raise NotImplementedError(self.lookup_revision_id)
219
 
 
220
 
    def all_revision_ids(self, mapping=None):
221
 
        """See Repository.all_revision_ids()."""
222
 
        raise NotImplementedError(self.all_revision_ids)
223
 
 
224
 
    def get_default_mapping(self):
225
 
        """Get the default mapping for this repository."""
226
 
        raise NotImplementedError(self.get_default_mapping)
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_inventory_sha1(self, revision_id):
233
 
        """Get the sha1 for the XML representation of an inventory.
234
 
 
235
 
        :param revision_id: Revision id of the inventory for which to return
236
 
         the SHA1.
237
 
        :return: XML string
238
 
        """
239
 
 
240
 
        return osutils.sha_string(self.get_inventory_xml(revision_id))
241
 
 
242
 
    def get_revision_xml(self, revision_id):
243
 
        """Return the XML representation of a revision.
244
 
 
245
 
        :param revision_id: Revision for which to return the XML.
246
 
        :return: XML string
247
 
        """
248
 
        return self._serializer.write_revision_to_string(
249
 
            self.get_revision(revision_id))
250
 
 
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)