← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bundle/commands.py

  • Committer: Alexander Belchenko
  • Date: 2006-06-29 08:41:31 UTC
  • mto: (1860.1.1 win32.installer)
  • mto: This revision was merged to the branch mainline in revision 1906.
  • Revision ID: bialix@ukr.net-20060629084131-3ea4d44e3204e36f
win32 installer for bzr.dev.0.9

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bundle/commands.py
1
 
# Copyright (C) 2006 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
 
1
#!/usr/bin/env python
16
2
"""\
17
3
This is an attempt to take the internal delta object, and represent
18
4
it as a single-file text-only changeset.
21
7
"""
22
8
 
23
9
import sys
24
 
from cStringIO import StringIO
25
 
 
26
 
from bzrlib.lazy_import import lazy_import
27
 
lazy_import(globals(), """
28
 
from bzrlib import (
29
 
    branch,
30
 
    errors,
31
 
    merge_directive,
32
 
    revision as _mod_revision,
33
 
    urlutils,
34
 
    transport,
35
 
    )
36
 
""")
37
 
 
38
 
from bzrlib.commands import Command
 
10
 
 
11
from bzrlib.branch import Branch
 
12
from bzrlib.commands import Command, register_command
 
13
import bzrlib.errors as errors
39
14
from bzrlib.option import Option
 
15
from bzrlib.revision import (common_ancestor, MultipleRevisionSources,
 
16
                             NULL_REVISION)
 
17
from bzrlib.revisionspec import RevisionSpec
40
18
from bzrlib.trace import note
41
19
 
42
20
 
43
 
class cmd_bundle_info(Command):
44
 
    """Output interesting stats about a bundle"""
45
 
 
46
 
    hidden = True
47
 
    takes_args = ['location']
48
 
    takes_options = ['verbose']
49
 
    encoding_type = 'exact'
50
 
 
51
 
    def run(self, location, verbose=False):
52
 
        from bzrlib.bundle.serializer import read_bundle
53
 
        from bzrlib.bundle import read_mergeable_from_url
54
 
        from bzrlib import osutils
55
 
        term_encoding = osutils.get_terminal_encoding()
56
 
        bundle_info = read_mergeable_from_url(location)
57
 
        if isinstance(bundle_info, merge_directive._BaseMergeDirective):
58
 
            bundle_file = StringIO(bundle_info.get_raw_bundle())
59
 
            bundle_info = read_bundle(bundle_file)
60
 
        else:
61
 
            if verbose:
62
 
                raise errors.BzrCommandError('--verbose requires a merge'
63
 
                    ' directive')
64
 
        reader_method = getattr(bundle_info, 'get_bundle_reader', None)
65
 
        if reader_method is None:
66
 
            raise errors.BzrCommandError('Bundle format not supported')
67
 
 
68
 
        by_kind = {}
69
 
        file_ids = set()
70
 
        for bytes, parents, repo_kind, revision_id, file_id\
71
 
            in reader_method().iter_records():
72
 
            by_kind.setdefault(repo_kind, []).append(
73
 
                (bytes, parents, repo_kind, revision_id, file_id))
74
 
            if file_id is not None:
75
 
                file_ids.add(file_id)
76
 
        self.outf.write('Records\n')
77
 
        for kind, records in sorted(by_kind.iteritems()):
78
 
            multiparent = sum(1 for b, m, k, r, f in records if
79
 
                              len(m.get('parents', [])) > 1)
80
 
            self.outf.write('%s: %d (%d multiparent)\n' % \
81
 
                (kind, len(records), multiparent))
82
 
        self.outf.write('unique files: %d\n' % len(file_ids))
83
 
        self.outf.write('\n')
84
 
        nicks = set()
85
 
        committers = set()
86
 
        for revision in bundle_info.real_revisions:
87
 
            if 'branch-nick' in revision.properties:
88
 
                nicks.add(revision.properties['branch-nick'])
89
 
            committers.add(revision.committer)
90
 
 
91
 
        self.outf.write('Revisions\n')
92
 
        self.outf.write(('nicks: %s\n'
93
 
            % ', '.join(sorted(nicks))).encode(term_encoding, 'replace'))
94
 
        self.outf.write(('committers: \n%s\n' %
95
 
        '\n'.join(sorted(committers)).encode(term_encoding, 'replace')))
96
 
        if verbose:
97
 
            self.outf.write('\n')
98
 
            bundle_file.seek(0)
99
 
            line = bundle_file.readline()
100
 
            line = bundle_file.readline()
101
 
            content = bundle_file.read().decode('bz2')
102
 
            self.outf.write("Decoded contents\n")
103
 
            self.outf.write(content)
104
 
            self.outf.write('\n')
 
21
class cmd_send_changeset(Command):
 
22
    """Send a bundled up changset via mail.
 
23
 
 
24
    If no revision has been specified, the last commited change will
 
25
    be sent.
 
26
 
 
27
    Subject of the mail can be specified by the --message option,
 
28
    otherwise information from the changeset log will be used.
 
29
 
 
30
    A editor will be spawned where the user may enter a description
 
31
    of the changeset.  The description can be read from a file with
 
32
    the --file FILE option.
 
33
    """
 
34
    takes_options = ['revision', 'message', 'file']
 
35
    takes_args = ['to?']
 
36
 
 
37
    def run(self, to=None, message=None, revision=None, file=None):
 
38
        from bzrlib.errors import BzrCommandError
 
39
        from send_changeset import send_changeset
 
40
        
 
41
        if isinstance(revision, (list, tuple)):
 
42
            if len(revision) > 1:
 
43
                raise BzrCommandError('We do not support rollup-changesets yet.')
 
44
            revision = revision[0]
 
45
 
 
46
        b = Branch.open_containing('.')
 
47
 
 
48
        if not to:
 
49
            try:
 
50
                to = b.controlfile('x-send-address', 'rb').read().strip('\n')
 
51
            except:
 
52
                raise BzrCommandError('destination address is not known')
 
53
 
 
54
        if not isinstance(revision, (list, tuple)):
 
55
            revision = [revision]
 
56
 
 
57
        send_changeset(b, revision, to, message, file)
 
58
 
 
59
 
 
60
class cmd_bundle_revisions(Command):
 
61
    """Generate a revision bundle.
 
62
 
 
63
    This bundle contains all of the meta-information of a
 
64
    diff, rather than just containing the patch information.
 
65
 
 
66
    You can apply it to another tree using 'bzr merge'.
 
67
 
 
68
    bzr bundle-revisions
 
69
        - Bundle for the last commit
 
70
    bzr bundle-revisions BASE
 
71
        - Bundle to apply the current tree into BASE
 
72
    bzr bundle-revisions --revision A
 
73
        - Bundle for revision A
 
74
    bzr bundle-revisions --revision A..B
 
75
        - Bundle to transform A into B
 
76
    bzr bundle-revisions --revision A..B BASE
 
77
        - Bundle to transform revision A of BASE into revision B
 
78
          of the local tree
 
79
    """
 
80
    takes_options = ['verbose', 'revision', 'remember',
 
81
                     Option("output", help="write bundle to specified file",
 
82
                            type=unicode)]
 
83
    takes_args = ['base?']
 
84
    aliases = ['bundle']
 
85
 
 
86
    def run(self, base=None, revision=None, output=None, remember=False):
 
87
        from bzrlib import user_encoding
 
88
        from bzrlib.bundle.serializer import write_bundle
 
89
 
 
90
        target_branch = Branch.open_containing(u'.')[0]
 
91
        submit_branch = target_branch.get_submit_branch()
 
92
 
 
93
        if base is None:
 
94
            base_specified = False
 
95
            base = submit_branch
 
96
            note('Using saved location: %s' % base)
 
97
        else:
 
98
            base_specified = True
 
99
 
 
100
        if base is None:
 
101
            base = target_branch.get_parent()
 
102
            if base is None:
 
103
                raise errors.BzrCommandError("No base branch known or"
 
104
                                             " specified.")
 
105
            else:
 
106
                note('Using saved location: %s' % base)
 
107
        base_branch = Branch.open(base)
 
108
 
 
109
        # We don't want to lock the same branch across
 
110
        # 2 different branches
 
111
        if target_branch.base == base_branch.base:
 
112
            base_branch = target_branch 
 
113
        if submit_branch is None or remember:
 
114
            if base_specified:
 
115
                target_branch.set_submit_branch(base_branch.base)
 
116
            elif remember:
 
117
                raise errors.BzrCommandError('--remember requires a branch to'
 
118
                                             ' be specified.')
 
119
 
 
120
        base_revision = None
 
121
        if revision is None:
 
122
            target_revision = target_branch.last_revision()
 
123
        elif len(revision) == 1:
 
124
            target_revision = revision[0].in_history(target_branch).rev_id
 
125
            if base_branch is not None:
 
126
                base_revision = base_branch.last_revision()
 
127
        elif len(revision) == 2:
 
128
            target_revision = revision[1].in_history(target_branch).rev_id
 
129
            if base_branch is not None:
 
130
                base_revision = revision[0].in_history(base_branch).rev_id
 
131
            else:
 
132
                base_revision = revision[0].in_history(target_branch).rev_id
 
133
        else:
 
134
            raise errors.BzrCommandError('--revision takes 1 or 2 parameters')
 
135
 
 
136
        if revision is None or len(revision) == 1:
 
137
            if base_branch is not None:
 
138
                target_branch.repository.fetch(base_branch.repository, 
 
139
                                               base_branch.last_revision())
 
140
                base_revision = common_ancestor(base_branch.last_revision(),
 
141
                                                target_revision,
 
142
                                                target_branch.repository)
 
143
                if base_revision is None:
 
144
                    base_revision = NULL_REVISION
 
145
 
 
146
        if base_revision is None:
 
147
            rev = target_branch.repository.get_revision(target_revision)
 
148
            if rev.parent_ids:
 
149
                base_revision = rev.parent_ids[0]
 
150
            else:
 
151
                base_revision = NULL_REVISION
 
152
 
 
153
        if base_branch is not None:
 
154
            target_branch.repository.fetch(base_branch.repository, 
 
155
                                           revision_id=base_revision)
 
156
            del base_branch
 
157
 
 
158
        if output is not None:
 
159
            fileobj = file(output, 'wb')
 
160
        else:
 
161
            fileobj = sys.stdout
 
162
        write_bundle(target_branch.repository, target_revision, base_revision,
 
163
                     fileobj)
 
164
 
 
165
 
 
166
class cmd_verify_changeset(Command):
 
167
    """Read a written changeset, and make sure it is valid.
 
168
 
 
169
    """
 
170
    takes_args = ['filename?']
 
171
 
 
172
    def run(self, filename=None):
 
173
        from read_changeset import read_changeset
 
174
        #from bzrlib.xml import serializer_v4
 
175
 
 
176
        b, relpath = Branch.open_containing('.')
 
177
 
 
178
        if filename is None or filename == '-':
 
179
            f = sys.stdin
 
180
        else:
 
181
            f = open(filename, 'U')
 
182
 
 
183
        cset_info, cset_tree = read_changeset(f, b)
 
184
        # print cset_info
 
185
        # print cset_tree
 
186
        #serializer_v4.write(cset_tree.inventory, sys.stdout)