~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Martin Pool
  • Date: 2005-05-30 01:39:13 UTC
  • Revision ID: mbp@sourcefrog.net-20050530013913-4ac43c29e1302170
- make sure any bzr output is flushed before 
  running external diff

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
 
 
19
def commit(branch, message,
 
20
           timestamp=None,
 
21
           timezone=None,
 
22
           committer=None,
 
23
           verbose=True,
 
24
           specific_files=None,
 
25
           rev_id=None):
 
26
    """Commit working copy as a new revision.
 
27
 
 
28
    The basic approach is to add all the file texts into the
 
29
    store, then the inventory, then make a new revision pointing
 
30
    to that inventory and store that.
 
31
 
 
32
    This is not quite safe if the working copy changes during the
 
33
    commit; for the moment that is simply not allowed.  A better
 
34
    approach is to make a temporary copy of the files before
 
35
    computing their hashes, and then add those hashes in turn to
 
36
    the inventory.  This should mean at least that there are no
 
37
    broken hash pointers.  There is no way we can get a snapshot
 
38
    of the whole directory at an instant.  This would also have to
 
39
    be robust against files disappearing, moving, etc.  So the
 
40
    whole thing is a bit hard.
 
41
 
 
42
    timestamp -- if not None, seconds-since-epoch for a
 
43
         postdated/predated commit.
 
44
 
 
45
    specific_files
 
46
        If true, commit only those files.
 
47
 
 
48
    rev_id
 
49
        If set, use this as the new revision id.
 
50
        Useful for test or import commands that need to tightly
 
51
        control what revisions are assigned.  If you duplicate
 
52
        a revision id that exists elsewhere it is your own fault.
 
53
        If null (default), a time/random revision id is generated.
 
54
    """
 
55
 
 
56
    import os, time, tempfile
 
57
 
 
58
    from inventory import Inventory
 
59
    from osutils import isdir, isfile, sha_string, quotefn, \
 
60
         local_time_offset, username, kind_marker, is_inside_any
 
61
    
 
62
    from branch import gen_file_id
 
63
    from errors import BzrError
 
64
    from revision import Revision
 
65
    from trace import mutter, note
 
66
 
 
67
    branch.lock('w')
 
68
 
 
69
    try:
 
70
        # First walk over the working inventory; and both update that
 
71
        # and also build a new revision inventory.  The revision
 
72
        # inventory needs to hold the text-id, sha1 and size of the
 
73
        # actual file versions committed in the revision.  (These are
 
74
        # not present in the working inventory.)  We also need to
 
75
        # detect missing/deleted files, and remove them from the
 
76
        # working inventory.
 
77
 
 
78
        work_tree = branch.working_tree()
 
79
        work_inv = work_tree.inventory
 
80
        inv = Inventory()
 
81
        basis = branch.basis_tree()
 
82
        basis_inv = basis.inventory
 
83
        missing_ids = []
 
84
 
 
85
        if verbose:
 
86
            note('looking for changes...')
 
87
 
 
88
        for path, entry in work_inv.iter_entries():
 
89
            ## TODO: Check that the file kind has not changed from the previous
 
90
            ## revision of this file (if any).
 
91
 
 
92
            entry = entry.copy()
 
93
 
 
94
            p = branch.abspath(path)
 
95
            file_id = entry.file_id
 
96
            mutter('commit prep file %s, id %r ' % (p, file_id))
 
97
 
 
98
            if specific_files and not is_inside_any(specific_files, path):
 
99
                if basis_inv.has_id(file_id):
 
100
                    # carry over with previous state
 
101
                    inv.add(basis_inv[file_id].copy())
 
102
                else:
 
103
                    # omit this from committed inventory
 
104
                    pass
 
105
                continue
 
106
 
 
107
            if not work_tree.has_id(file_id):
 
108
                if verbose:
 
109
                    print('deleted %s%s' % (path, kind_marker(entry.kind)))
 
110
                mutter("    file is missing, removing from inventory")
 
111
                missing_ids.append(file_id)
 
112
                continue
 
113
 
 
114
            inv.add(entry)
 
115
 
 
116
            if basis_inv.has_id(file_id):
 
117
                old_kind = basis_inv[file_id].kind
 
118
                if old_kind != entry.kind:
 
119
                    raise BzrError("entry %r changed kind from %r to %r"
 
120
                            % (file_id, old_kind, entry.kind))
 
121
 
 
122
            if entry.kind == 'directory':
 
123
                if not isdir(p):
 
124
                    raise BzrError("%s is entered as directory but not a directory"
 
125
                                   % quotefn(p))
 
126
            elif entry.kind == 'file':
 
127
                if not isfile(p):
 
128
                    raise BzrError("%s is entered as file but is not a file" % quotefn(p))
 
129
 
 
130
                new_sha1 = work_tree.get_file_sha1(file_id)
 
131
 
 
132
                old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
 
133
                if (old_ie
 
134
                    and old_ie.text_sha1 == new_sha1):
 
135
                    ## assert content == basis.get_file(file_id).read()
 
136
                    entry.text_id = old_ie.text_id
 
137
                    entry.text_sha1 = new_sha1
 
138
                    entry.text_size = old_ie.text_size
 
139
                    mutter('    unchanged from previous text_id {%s}' %
 
140
                           entry.text_id)
 
141
                else:
 
142
                    content = file(p, 'rb').read()
 
143
 
 
144
                    # calculate the sha again, just in case the file contents
 
145
                    # changed since we updated the cache
 
146
                    entry.text_sha1 = sha_string(content)
 
147
                    entry.text_size = len(content)
 
148
 
 
149
                    entry.text_id = gen_file_id(entry.name)
 
150
                    branch.text_store.add(content, entry.text_id)
 
151
                    mutter('    stored with text_id {%s}' % entry.text_id)
 
152
                    if verbose:
 
153
                        if not old_ie:
 
154
                            print('added %s' % path)
 
155
                        elif (old_ie.name == entry.name
 
156
                              and old_ie.parent_id == entry.parent_id):
 
157
                            print('modified %s' % path)
 
158
                        else:
 
159
                            print('renamed %s' % path)
 
160
 
 
161
 
 
162
        for file_id in missing_ids:
 
163
            # Any files that have been deleted are now removed from the
 
164
            # working inventory.  Files that were not selected for commit
 
165
            # are left as they were in the working inventory and ommitted
 
166
            # from the revision inventory.
 
167
 
 
168
            # have to do this later so we don't mess up the iterator.
 
169
            # since parents may be removed before their children we
 
170
            # have to test.
 
171
 
 
172
            # FIXME: There's probably a better way to do this; perhaps
 
173
            # the workingtree should know how to filter itbranch.
 
174
            if work_inv.has_id(file_id):
 
175
                del work_inv[file_id]
 
176
 
 
177
 
 
178
        if rev_id is None:
 
179
            rev_id = _gen_revision_id(time.time())
 
180
        inv_id = rev_id
 
181
 
 
182
        inv_tmp = tempfile.TemporaryFile()
 
183
        inv.write_xml(inv_tmp)
 
184
        inv_tmp.seek(0)
 
185
        branch.inventory_store.add(inv_tmp, inv_id)
 
186
        mutter('new inventory_id is {%s}' % inv_id)
 
187
 
 
188
        branch._write_inventory(work_inv)
 
189
 
 
190
        if timestamp == None:
 
191
            timestamp = time.time()
 
192
 
 
193
        if committer == None:
 
194
            committer = username()
 
195
 
 
196
        if timezone == None:
 
197
            timezone = local_time_offset()
 
198
 
 
199
        mutter("building commit log message")
 
200
        rev = Revision(timestamp=timestamp,
 
201
                       timezone=timezone,
 
202
                       committer=committer,
 
203
                       precursor = branch.last_patch(),
 
204
                       message = message,
 
205
                       inventory_id=inv_id,
 
206
                       revision_id=rev_id)
 
207
 
 
208
        rev_tmp = tempfile.TemporaryFile()
 
209
        rev.write_xml(rev_tmp)
 
210
        rev_tmp.seek(0)
 
211
        branch.revision_store.add(rev_tmp, rev_id)
 
212
        mutter("new revision_id is {%s}" % rev_id)
 
213
 
 
214
        ## XXX: Everything up to here can simply be orphaned if we abort
 
215
        ## the commit; it will leave junk files behind but that doesn't
 
216
        ## matter.
 
217
 
 
218
        ## TODO: Read back the just-generated changeset, and make sure it
 
219
        ## applies and recreates the right state.
 
220
 
 
221
        ## TODO: Also calculate and store the inventory SHA1
 
222
        mutter("committing patch r%d" % (branch.revno() + 1))
 
223
 
 
224
        branch.append_revision(rev_id)
 
225
 
 
226
        if verbose:
 
227
            note("commited r%d" % branch.revno())
 
228
    finally:
 
229
        branch.unlock()
 
230
 
 
231
 
 
232
 
 
233
def _gen_revision_id(when):
 
234
    """Return new revision-id."""
 
235
    from binascii import hexlify
 
236
    from osutils import rand_bytes, compact_date, user_email
 
237
 
 
238
    s = '%s-%s-' % (user_email(), compact_date(when))
 
239
    s += hexlify(rand_bytes(8))
 
240
    return s
 
241
 
 
242