← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge_directive.py

  • Committer: Vincent Ladeuil
  • Date: 2007-11-24 14:20:59 UTC
  • mto: (3928.1.1 bzr.integration)
  • mto: This revision was merged to the branch mainline in revision 3929.
  • Revision ID: v.ladeuil+lp@free.fr-20071124142059-2114qtsgfdv8g9p1
Ssl files needed for the test https server.

* bzrlib/tests/ssl_certs/create_ssls.py: 
Script to create the ssl keys and certificates.

* bzrlib/tests/ssl_certs/server.crt: 
Server certificate signed by the certificate authority.

* bzrlib/tests/ssl_certs/server.csr: 
Server certificate signing request.

* bzrlib/tests/ssl_certs/server_without_pass.key: 
Server key usable without password.

* bzrlib/tests/ssl_certs/server_with_pass.key: 
Server key.

* bzrlib/tests/ssl_certs/ca.key: 
Certificate authority private key.

* bzrlib/tests/ssl_certs/ca.crt: 
Certificate authority certificate.

* bzrlib/tests/ssl_certs/__init__.py: 
Provide access to ssl files (keys and certificates). 

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
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
18
from StringIO import StringIO
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,
37
35
from bzrlib.email_message import EmailMessage
38
36
 
39
37
 
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
 
38
class _BaseMergeDirective(object):
80
39
 
81
40
    def __init__(self, revision_id, testament_sha1, time, timezone,
82
41
                 target_branch, patch=None, source_branch=None, message=None,
102
61
        self.source_branch = source_branch
103
62
        self.message = message
104
63
 
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
64
    def _to_lines(self, base_revision=False):
127
65
        """Serialize as a list of lines
128
66
 
142
80
        lines.append('# \n')
143
81
        return lines
144
82
 
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
83
    @classmethod
153
84
    def from_objects(klass, repository, revision_id, time, timezone,
154
85
                 target_branch, patch_type='bundle',
205
136
        return klass(revision_id, t.as_sha1(), time, timezone, target_branch,
206
137
            patch, patch_type, public_branch, message)
207
138
 
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
139
    @staticmethod
224
140
    def _generate_diff(repository, revision_id, ancestor_id):
225
141
        tree_1 = repository.revision_tree(ancestor_id)
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, stream_input=False)
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):
466
323
        return None, self.revision_id, 'inapplicable'
467
324
 
468
325
 
469
 
class MergeDirective2(BaseMergeDirective):
 
326
class MergeDirective2(_BaseMergeDirective):
470
327
 
471
328
    _format_string = 'Bazaar merge directive format 2 (Bazaar 0.90)'
472
329
 
475
332
                 bundle=None, base_revision_id=None):
476
333
        if source_branch is None and bundle is None:
477
334
            raise errors.NoMergeSource()
478
 
        BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
 
335
        _BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
479
336
            timezone, target_branch, patch, source_branch, message)
480
337
        self.bundle = bundle
481
338
        self.base_revision_id = base_revision_id
618
475
                    revision_id):
619
476
                    raise errors.PublicBranchOutOfDate(public_branch,
620
477
                                                       revision_id)
621
 
            testament_sha1 = t.as_sha1()
622
478
        finally:
623
479
            for entry in reversed(locked):
624
480
                entry.unlock()
625
 
        return klass(revision_id, testament_sha1, time, timezone,
626
 
            target_branch, patch, public_branch, message, bundle,
627
 
            base_revision_id)
 
481
        return klass(revision_id, t.as_sha1(), time, timezone, target_branch,
 
482
            patch, public_branch, message, bundle, base_revision_id)
628
483
 
629
484
    def _verify_patch(self, repository):
630
485
        calculated_patch = self._generate_diff(repository, self.revision_id,
666
521
_format_registry = MergeDirectiveFormatRegistry()
667
522
_format_registry.register(MergeDirective)
668
523
_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
524
_format_registry.register(MergeDirective2,
673
525
                          'Bazaar merge directive format 2 (Bazaar 0.19)')