/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/merge_directive.py

  • Committer: Aaron Bentley
  • Date: 2007-06-26 19:31:00 UTC
  • mto: (2520.5.2 bzr.mpbundle)
  • mto: This revision was merged to the branch mainline in revision 2631.
  • Revision ID: abentley@panoramicfeedback.com-20070626193100-d6lhaut5mixlzw5r
Use a registry to look up xml serializers by format

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge_directive.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
 
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
from email import Message
18
19
from StringIO import StringIO
19
 
import re
20
20
 
21
21
from bzrlib import (
22
22
    branch as _mod_branch,
23
23
    diff,
24
24
    errors,
25
25
    gpg,
26
 
    hooks,
27
26
    registry,
28
27
    revision as _mod_revision,
29
28
    rio,
30
29
    testament,
31
30
    timestamp,
32
 
    trace,
33
31
    )
34
32
from bzrlib.bundle import (
35
33
    serializer as bundle_serializer,
36
34
    )
37
 
from bzrlib.email_message import EmailMessage
38
 
 
39
 
 
40
 
class MergeRequestBodyParams(object):
41
 
    """Parameter object for the merge_request_body hook."""
42
 
 
43
 
    def __init__(self, body, orig_body, directive, to, basename, subject,
44
 
                 branch, tree=None):
45
 
        self.body = body
46
 
        self.orig_body = orig_body
47
 
        self.directive = directive
48
 
        self.branch = branch
49
 
        self.tree = tree
50
 
        self.to = to
51
 
        self.basename = basename
52
 
        self.subject = subject
53
 
 
54
 
 
55
 
class MergeDirectiveHooks(hooks.Hooks):
56
 
    """Hooks for MergeDirective classes."""
57
 
 
58
 
    def __init__(self):
59
 
        hooks.Hooks.__init__(self)
60
 
        self.create_hook(hooks.HookPoint('merge_request_body',
61
 
            "Called with a MergeRequestBodyParams when a body is needed for"
62
 
            " a merge request.  Callbacks must return a body.  If more"
63
 
            " than one callback is registered, the output of one callback is"
64
 
            " provided to the next.", (1, 15, 0), False))
65
 
 
66
 
 
67
 
class BaseMergeDirective(object):
68
 
    """A request to perform a merge into a branch.
69
 
 
70
 
    This is the base class that all merge directive implementations 
71
 
    should derive from.
72
 
 
73
 
    :cvar multiple_output_files: Whether or not this merge directive 
74
 
        stores a set of revisions in more than one file
75
 
    """
76
 
 
77
 
    hooks = MergeDirectiveHooks()
78
 
 
79
 
    multiple_output_files = False
 
35
 
 
36
 
 
37
class _BaseMergeDirective(object):
80
38
 
81
39
    def __init__(self, revision_id, testament_sha1, time, timezone,
82
40
                 target_branch, patch=None, source_branch=None, message=None,
102
60
        self.source_branch = source_branch
103
61
        self.message = message
104
62
 
105
 
    def to_lines(self):
106
 
        """Serialize as a list of lines
107
 
 
108
 
        :return: a list of lines
109
 
        """
110
 
        raise NotImplementedError(self.to_lines)
111
 
 
112
 
    def to_files(self):
113
 
        """Serialize as a set of files.
114
 
 
115
 
        :return: List of tuples with filename and contents as lines
116
 
        """
117
 
        raise NotImplementedError(self.to_files)
118
 
 
119
 
    def get_raw_bundle(self):
120
 
        """Return the bundle for this merge directive.
121
 
 
122
 
        :return: bundle text or None if there is no bundle
123
 
        """
124
 
        return None
125
 
 
126
 
    def _to_lines(self, base_revision=False):
 
63
    def _to_lines(self):
127
64
        """Serialize as a list of lines
128
65
 
129
66
        :return: a list of lines
135
72
        for key in ('source_branch', 'message'):
136
73
            if self.__dict__[key] is not None:
137
74
                stanza.add(key, self.__dict__[key])
138
 
        if base_revision:
139
 
            stanza.add('base_revision_id', self.base_revision_id)
140
75
        lines = ['# ' + self._format_string + '\n']
141
76
        lines.extend(rio.to_patch_lines(stanza))
142
77
        lines.append('# \n')
143
78
        return lines
144
79
 
145
 
    def write_to_directory(self, path):
146
 
        """Write this merge directive to a series of files in a directory.
147
 
 
148
 
        :param path: Filesystem path to write to
149
 
        """
150
 
        raise NotImplementedError(self.write_to_directory)
151
 
 
152
80
    @classmethod
153
81
    def from_objects(klass, repository, revision_id, time, timezone,
154
82
                 target_branch, patch_type='bundle',
196
124
            patch = type_handler[patch_type](repository, revision_id,
197
125
                                             ancestor_id)
198
126
 
199
 
        if public_branch is not None and patch_type != 'bundle':
200
 
            public_branch_obj = _mod_branch.Branch.open(public_branch)
201
 
            if not public_branch_obj.repository.has_revision(revision_id):
202
 
                raise errors.PublicBranchOutOfDate(public_branch,
203
 
                                                   revision_id)
 
127
            if public_branch is not None and patch_type != 'bundle':
 
128
                public_branch_obj = _mod_branch.Branch.open(public_branch)
 
129
                if not public_branch_obj.repository.has_revision(revision_id):
 
130
                    raise errors.PublicBranchOutOfDate(public_branch,
 
131
                                                       revision_id)
204
132
 
205
133
        return klass(revision_id, t.as_sha1(), time, timezone, target_branch,
206
134
            patch, patch_type, public_branch, message)
207
135
 
208
 
    def get_disk_name(self, branch):
209
 
        """Generate a suitable basename for storing this directive on disk
210
 
 
211
 
        :param branch: The Branch this merge directive was generated fro
212
 
        :return: A string
213
 
        """
214
 
        revno, revision_id = branch.last_revision_info()
215
 
        if self.revision_id == revision_id:
216
 
            revno = [revno]
217
 
        else:
218
 
            revno = branch.get_revision_id_to_revno_map().get(self.revision_id,
219
 
                ['merge'])
220
 
        nick = re.sub('(\W+)', '-', branch.nick).strip('-')
221
 
        return '%s-%s' % (nick, '.'.join(str(n) for n in revno))
222
 
 
223
136
    @staticmethod
224
137
    def _generate_diff(repository, revision_id, ancestor_id):
225
138
        tree_1 = repository.revision_tree(ancestor_id)
254
167
        :return: an email message
255
168
        """
256
169
        mail_from = branch.get_config().username()
 
170
        message = Message.Message()
 
171
        message['To'] = mail_to
 
172
        message['From'] = mail_from
257
173
        if self.message is not None:
258
 
            subject = self.message
 
174
            message['Subject'] = self.message
259
175
        else:
260
176
            revision = branch.repository.get_revision(self.revision_id)
261
 
            subject = revision.message
 
177
            message['Subject'] = revision.message
262
178
        if sign:
263
179
            body = self.to_signed(branch)
264
180
        else:
265
181
            body = ''.join(self.to_lines())
266
 
        message = EmailMessage(mail_from, mail_to, subject, body)
 
182
        message.set_payload(body)
267
183
        return message
268
184
 
269
185
    def install_revisions(self, target_repo):
274
190
                    StringIO(self.get_raw_bundle()))
275
191
                # We don't use the bundle's target revision, because
276
192
                # MergeDirective.revision_id is authoritative.
277
 
                try:
278
 
                    info.install_revisions(target_repo, stream_input=False)
279
 
                except errors.RevisionNotPresent:
280
 
                    # At least one dependency isn't present.  Try installing
281
 
                    # missing revisions from the submit branch
282
 
                    try:
283
 
                        submit_branch = \
284
 
                            _mod_branch.Branch.open(self.target_branch)
285
 
                    except errors.NotBranchError:
286
 
                        raise errors.TargetNotBranch(self.target_branch)
287
 
                    missing_revisions = []
288
 
                    bundle_revisions = set(r.revision_id for r in
289
 
                                           info.real_revisions)
290
 
                    for revision in info.real_revisions:
291
 
                        for parent_id in revision.parent_ids:
292
 
                            if (parent_id not in bundle_revisions and
293
 
                                not target_repo.has_revision(parent_id)):
294
 
                                missing_revisions.append(parent_id)
295
 
                    # reverse missing revisions to try to get heads first
296
 
                    unique_missing = []
297
 
                    unique_missing_set = set()
298
 
                    for revision in reversed(missing_revisions):
299
 
                        if revision in unique_missing_set:
300
 
                            continue
301
 
                        unique_missing.append(revision)
302
 
                        unique_missing_set.add(revision)
303
 
                    for missing_revision in unique_missing:
304
 
                        target_repo.fetch(submit_branch.repository,
305
 
                                          missing_revision)
306
 
                    info.install_revisions(target_repo, stream_input=False)
 
193
                info.install_revisions(target_repo)
307
194
            else:
308
195
                source_branch = _mod_branch.Branch.open(self.source_branch)
309
196
                target_repo.fetch(source_branch.repository, self.revision_id)
310
197
        return self.revision_id
311
198
 
312
 
    def compose_merge_request(self, mail_client, to, body, branch, tree=None):
313
 
        """Compose a request to merge this directive.
314
 
 
315
 
        :param mail_client: The mail client to use for composing this request.
316
 
        :param to: The address to compose the request to.
317
 
        :param branch: The Branch that was used to produce this directive.
318
 
        :param tree: The Tree (if any) for the Branch used to produce this
319
 
            directive.
320
 
        """
321
 
        basename = self.get_disk_name(branch)
322
 
        subject = '[MERGE] '
323
 
        if self.message is not None:
324
 
            subject += self.message
325
 
        else:
326
 
            revision = branch.repository.get_revision(self.revision_id)
327
 
            subject += revision.get_summary()
328
 
        if getattr(mail_client, 'supports_body', False):
329
 
            orig_body = body
330
 
            for hook in self.hooks['merge_request_body']:
331
 
                params = MergeRequestBodyParams(body, orig_body, self,
332
 
                                                to, basename, subject, branch,
333
 
                                                tree)
334
 
                body = hook(params)
335
 
        elif len(self.hooks['merge_request_body']) > 0:
336
 
            trace.warning('Cannot run merge_request_body hooks because mail'
337
 
                          ' client %s does not support message bodies.',
338
 
                        mail_client.__class__.__name__)
339
 
        mail_client.compose_merge_request(to, subject,
340
 
                                          ''.join(self.to_lines()),
341
 
                                          basename, body)
342
 
 
343
 
 
344
 
class MergeDirective(BaseMergeDirective):
 
199
 
 
200
class MergeDirective(_BaseMergeDirective):
345
201
 
346
202
    """A request to perform a merge into a branch.
347
203
 
376
232
        :param source_branch: A public location to merge the revision from
377
233
        :param message: The message to use when committing this merge
378
234
        """
379
 
        BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
 
235
        _BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
380
236
            timezone, target_branch, patch, source_branch, message)
381
 
        if patch_type not in (None, 'diff', 'bundle'):
382
 
            raise ValueError(patch_type)
 
237
        assert patch_type in (None, 'diff', 'bundle'), patch_type
383
238
        if patch_type != 'bundle' and source_branch is None:
384
239
            raise errors.NoMergeSource()
385
240
        if patch_type is not None and patch is None:
409
264
        :return: a MergeRequest
410
265
        """
411
266
        line_iter = iter(lines)
412
 
        firstline = ""
413
267
        for line in line_iter:
414
268
            if line.startswith('# Bazaar merge directive format '):
415
 
                return _format_registry.get(line[2:].rstrip())._from_lines(
416
 
                    line_iter)
417
 
            firstline = firstline or line.strip()
418
 
        raise errors.NotAMergeDirective(firstline)
 
269
                break
 
270
        else:
 
271
            if len(lines) > 0:
 
272
                raise errors.NotAMergeDirective(lines[0])
 
273
            else:
 
274
                raise errors.NotAMergeDirective('')
 
275
        return _format_registry.get(line[2:].rstrip())._from_lines(line_iter)
419
276
 
420
277
    @classmethod
421
278
    def _from_lines(klass, line_iter):
458
315
                                       ancestor_id, s, '0.9')
459
316
        return s.getvalue()
460
317
 
461
 
    def get_merge_request(self, repository):
462
 
        """Provide data for performing a merge
463
 
 
464
 
        Returns suggested base, suggested target, and patch verification status
465
 
        """
466
 
        return None, self.revision_id, 'inapplicable'
467
 
 
468
 
 
469
 
class MergeDirective2(BaseMergeDirective):
470
 
 
471
 
    _format_string = 'Bazaar merge directive format 2 (Bazaar 0.90)'
 
318
 
 
319
class MergeDirective2(_BaseMergeDirective):
 
320
 
 
321
    _format_string = 'Bazaar merge directive format 2 (Bazaar 0.18)'
472
322
 
473
323
    def __init__(self, revision_id, testament_sha1, time, timezone,
474
324
                 target_branch, patch=None, source_branch=None, message=None,
475
 
                 bundle=None, base_revision_id=None):
 
325
                 bundle=None):
476
326
        if source_branch is None and bundle is None:
477
327
            raise errors.NoMergeSource()
478
 
        BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
 
328
        _BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
479
329
            timezone, target_branch, patch, source_branch, message)
480
330
        self.bundle = bundle
481
 
        self.base_revision_id = base_revision_id
482
331
 
483
332
    def _patch_type(self):
484
333
        if self.bundle is not None:
528
377
        time, timezone = timestamp.parse_patch_date(stanza.get('timestamp'))
529
378
        kwargs = {}
530
379
        for key in ('revision_id', 'testament_sha1', 'target_branch',
531
 
                    'source_branch', 'message', 'base_revision_id'):
 
380
                    'source_branch', 'message'):
532
381
            try:
533
382
                kwargs[key] = stanza.get(key)
534
383
            except KeyError:
535
384
                pass
536
385
        kwargs['revision_id'] = kwargs['revision_id'].encode('utf-8')
537
 
        kwargs['base_revision_id'] =\
538
 
            kwargs['base_revision_id'].encode('utf-8')
539
386
        return klass(time=time, timezone=timezone, patch=patch, bundle=bundle,
540
387
                     **kwargs)
541
388
 
542
389
    def to_lines(self):
543
 
        lines = self._to_lines(base_revision=True)
 
390
        lines = self._to_lines()
544
391
        if self.patch is not None:
545
392
            lines.append('# Begin patch\n')
546
393
            lines.extend(self.patch.splitlines(True))
551
398
 
552
399
    @classmethod
553
400
    def from_objects(klass, repository, revision_id, time, timezone,
554
 
                 target_branch, include_patch=True, include_bundle=True,
555
 
                 local_target_branch=None, public_branch=None, message=None,
556
 
                 base_revision_id=None):
 
401
                 target_branch, patch_type='bundle',
 
402
                 local_target_branch=None, public_branch=None, message=None):
557
403
        """Generate a merge directive from various objects
558
404
 
559
405
        :param repository: The repository containing the revision
561
407
        :param time: The POSIX timestamp of the date the request was issued.
562
408
        :param timezone: The timezone of the request
563
409
        :param target_branch: The url of the branch to merge into
564
 
        :param include_patch: If true, include a preview patch
565
 
        :param include_bundle: If true, include a bundle
 
410
        :param patch_type: 'bundle', 'diff' or None, depending on the type of
 
411
            patch desired.
566
412
        :param local_target_branch: a local copy of the target branch
567
413
        :param public_branch: location of a public branch containing the target
568
414
            revision.
569
415
        :param message: Message to use when committing the merge
570
416
        :return: The merge directive
571
417
 
572
 
        The public branch is always used if supplied.  If no bundle is
573
 
        included, the public branch must be supplied, and will be verified.
 
418
        The public branch is always used if supplied.  If the patch_type is
 
419
        not 'bundle', the public branch must be supplied, and will be verified.
574
420
 
575
421
        If the message is not supplied, the message from revision_id will be
576
422
        used for the commit.
589
435
            locked.append(submit_branch)
590
436
            if submit_branch.get_public_branch() is not None:
591
437
                target_branch = submit_branch.get_public_branch()
592
 
            submit_revision_id = submit_branch.last_revision()
593
 
            submit_revision_id = _mod_revision.ensure_null(submit_revision_id)
594
 
            graph = repository.get_graph(submit_branch.repository)
595
 
            ancestor_id = graph.find_unique_lca(revision_id,
596
 
                                                submit_revision_id)
597
 
            if base_revision_id is None:
598
 
                base_revision_id = ancestor_id
599
 
            if (include_patch, include_bundle) != (False, False):
600
 
                repository.fetch(submit_branch.repository, submit_revision_id)
601
 
            if include_patch:
602
 
                patch = klass._generate_diff(repository, revision_id,
603
 
                                             base_revision_id)
604
 
            else:
 
438
            if patch_type is None:
605
439
                patch = None
606
 
 
607
 
            if include_bundle:
608
 
                bundle = klass._generate_bundle(repository, revision_id,
609
 
                    ancestor_id).encode('base-64')
610
 
            else:
611
440
                bundle = None
 
441
            else:
 
442
                submit_revision_id = submit_branch.last_revision()
 
443
                submit_revision_id = _mod_revision.ensure_null(
 
444
                    submit_revision_id)
 
445
                repository.fetch(submit_branch.repository, submit_revision_id)
 
446
                graph = repository.get_graph()
 
447
                ancestor_id = graph.find_unique_lca(revision_id,
 
448
                                                    submit_revision_id)
 
449
                if patch_type in ('bundle', 'diff'):
 
450
                    patch = klass._generate_diff(repository, revision_id,
 
451
                                                 ancestor_id)
 
452
                if patch_type == 'bundle':
 
453
                    bundle = klass._generate_bundle(repository, revision_id,
 
454
                        ancestor_id).encode('base-64')
 
455
                else:
 
456
                    bundle = None
612
457
 
613
 
            if public_branch is not None and not include_bundle:
614
 
                public_branch_obj = _mod_branch.Branch.open(public_branch)
615
 
                public_branch_obj.lock_read()
616
 
                locked.append(public_branch_obj)
617
 
                if not public_branch_obj.repository.has_revision(
618
 
                    revision_id):
619
 
                    raise errors.PublicBranchOutOfDate(public_branch,
620
 
                                                       revision_id)
621
 
            testament_sha1 = t.as_sha1()
 
458
                if public_branch is not None and patch_type != 'bundle':
 
459
                    public_branch_obj = _mod_branch.Branch.open(public_branch)
 
460
                    public_branch_obj.lock_read()
 
461
                    locked.append(public_branch_obj)
 
462
                    if not public_branch_obj.repository.has_revision(
 
463
                        revision_id):
 
464
                        raise errors.PublicBranchOutOfDate(public_branch,
 
465
                                                           revision_id)
622
466
        finally:
623
467
            for entry in reversed(locked):
624
468
                entry.unlock()
625
 
        return klass(revision_id, testament_sha1, time, timezone,
626
 
            target_branch, patch, public_branch, message, bundle,
627
 
            base_revision_id)
628
 
 
629
 
    def _verify_patch(self, repository):
630
 
        calculated_patch = self._generate_diff(repository, self.revision_id,
631
 
                                               self.base_revision_id)
632
 
        # Convert line-endings to UNIX
633
 
        stored_patch = re.sub('\r\n?', '\n', self.patch)
634
 
        calculated_patch = re.sub('\r\n?', '\n', calculated_patch)
635
 
        # Strip trailing whitespace
636
 
        calculated_patch = re.sub(' *\n', '\n', calculated_patch)
637
 
        stored_patch = re.sub(' *\n', '\n', stored_patch)
638
 
        return (calculated_patch == stored_patch)
639
 
 
640
 
    def get_merge_request(self, repository):
641
 
        """Provide data for performing a merge
642
 
 
643
 
        Returns suggested base, suggested target, and patch verification status
644
 
        """
645
 
        verified = self._maybe_verify(repository)
646
 
        return self.base_revision_id, self.revision_id, verified
647
 
 
648
 
    def _maybe_verify(self, repository):
649
 
        if self.patch is not None:
650
 
            if self._verify_patch(repository):
651
 
                return 'verified'
652
 
            else:
653
 
                return 'failed'
654
 
        else:
655
 
            return 'inapplicable'
656
 
 
 
469
        return klass(revision_id, t.as_sha1(), time, timezone, target_branch,
 
470
            patch, public_branch, message, bundle)
657
471
 
658
472
class MergeDirectiveFormatRegistry(registry.Registry):
659
473
 
660
 
    def register(self, directive, format_string=None):
661
 
        if format_string is None:
662
 
            format_string = directive._format_string
663
 
        registry.Registry.register(self, format_string, directive)
 
474
    def register(self, directive):
 
475
        registry.Registry.register(self, directive._format_string, directive)
664
476
 
665
477
 
666
478
_format_registry = MergeDirectiveFormatRegistry()
667
479
_format_registry.register(MergeDirective)
668
480
_format_registry.register(MergeDirective2)
669
 
# 0.19 never existed.  It got renamed to 0.90.  But by that point, there were
670
 
# already merge directives in the wild that used 0.19. Registering with the old
671
 
# format string to retain compatibility with those merge directives.
672
 
_format_registry.register(MergeDirective2,
673
 
                          'Bazaar merge directive format 2 (Bazaar 0.19)')