← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bundle/commands.py

  • Committer: Robert Collins
  • Date: 2006-06-09 07:45:35 UTC
  • mto: (1755.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 1756.
  • Revision ID: robertc@robertcollins.net-20060609074535-3002a0209179b35c
Fixup '== None' usage in inventory.py.

Show diffs side-by-side

added added

removed removed

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