~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Martin Pool
  • Date: 2005-05-16 04:32:21 UTC
  • Revision ID: mbp@sourcefrog.net-20050516043221-12a9da66feb5d67b
clean up stat cache code:
- smarter UTF-8 and quopri encoding of file names
- check paths are not duplicated in cache
- check lines are well-formed
- more docs

Show diffs side-by-side

added added

removed removed

Lines of Context:
16
16
 
17
17
 
18
18
 
19
 
# FIXME: "bzr commit doc/format" commits doc/format.txt!
20
 
 
21
 
def commit(branch, message,
22
 
           timestamp=None,
23
 
           timezone=None,
 
19
def commit(branch, message, timestamp=None, timezone=None,
24
20
           committer=None,
25
21
           verbose=True,
26
22
           specific_files=None,
27
 
           rev_id=None,
28
 
           allow_pointless=True):
 
23
           rev_id=None):
29
24
    """Commit working copy as a new revision.
30
25
 
31
26
    The basic approach is to add all the file texts into the
42
37
    be robust against files disappearing, moving, etc.  So the
43
38
    whole thing is a bit hard.
44
39
 
45
 
    This raises PointlessCommit if there are no changes, no new merges,
46
 
    and allow_pointless  is false.
47
 
 
48
40
    timestamp -- if not None, seconds-since-epoch for a
49
41
         postdated/predated commit.
50
42
 
59
51
        If null (default), a time/random revision id is generated.
60
52
    """
61
53
 
62
 
    import time, tempfile
63
 
 
64
 
    from bzrlib.osutils import local_time_offset, username
65
 
    from bzrlib.branch import gen_file_id
66
 
    from bzrlib.errors import BzrError, PointlessCommit
67
 
    from bzrlib.revision import Revision, RevisionReference
68
 
    from bzrlib.trace import mutter, note
69
 
    from bzrlib.xml import pack_xml
70
 
 
71
 
    branch.lock_write()
72
 
 
73
 
    try:
74
 
        # First walk over the working inventory; and both update that
75
 
        # and also build a new revision inventory.  The revision
76
 
        # inventory needs to hold the text-id, sha1 and size of the
77
 
        # actual file versions committed in the revision.  (These are
78
 
        # not present in the working inventory.)  We also need to
79
 
        # detect missing/deleted files, and remove them from the
80
 
        # working inventory.
81
 
 
82
 
        work_tree = branch.working_tree()
83
 
        work_inv = work_tree.inventory
84
 
        basis = branch.basis_tree()
85
 
        basis_inv = basis.inventory
86
 
 
87
 
        if verbose:
88
 
            note('looking for changes...')
89
 
 
90
 
        pending_merges = branch.pending_merges()
91
 
 
92
 
        missing_ids, new_inv, any_changes = \
93
 
                     _gather_commit(branch,
94
 
                                    work_tree,
95
 
                                    work_inv,
96
 
                                    basis_inv,
97
 
                                    specific_files,
98
 
                                    verbose)
99
 
 
100
 
        if not (any_changes or allow_pointless or pending_merges):
101
 
            raise PointlessCommit()
102
 
 
103
 
        for file_id in missing_ids:
104
 
            # Any files that have been deleted are now removed from the
105
 
            # working inventory.  Files that were not selected for commit
106
 
            # are left as they were in the working inventory and ommitted
107
 
            # from the revision inventory.
108
 
 
109
 
            # have to do this later so we don't mess up the iterator.
110
 
            # since parents may be removed before their children we
111
 
            # have to test.
112
 
 
113
 
            # FIXME: There's probably a better way to do this; perhaps
114
 
            # the workingtree should know how to filter itbranch.
115
 
            if work_inv.has_id(file_id):
116
 
                del work_inv[file_id]
117
 
 
118
 
 
119
 
        if rev_id is None:
120
 
            rev_id = _gen_revision_id(time.time())
121
 
        inv_id = rev_id
122
 
 
123
 
        inv_tmp = tempfile.TemporaryFile()
124
 
        pack_xml(new_inv, inv_tmp)
125
 
        inv_tmp.seek(0)
126
 
        branch.inventory_store.add(inv_tmp, inv_id)
127
 
        mutter('new inventory_id is {%s}' % inv_id)
128
 
 
129
 
        # We could also just sha hash the inv_tmp file
130
 
        # however, in the case that branch.inventory_store.add()
131
 
        # ever actually does anything special
132
 
        inv_sha1 = branch.get_inventory_sha1(inv_id)
133
 
 
134
 
        branch._write_inventory(work_inv)
135
 
 
136
 
        if timestamp == None:
137
 
            timestamp = time.time()
138
 
 
139
 
        if committer == None:
140
 
            committer = username()
141
 
 
142
 
        if timezone == None:
143
 
            timezone = local_time_offset()
144
 
 
145
 
        mutter("building commit log message")
146
 
        rev = Revision(timestamp=timestamp,
147
 
                       timezone=timezone,
148
 
                       committer=committer,
149
 
                       message = message,
150
 
                       inventory_id=inv_id,
151
 
                       inventory_sha1=inv_sha1,
152
 
                       revision_id=rev_id)
153
 
 
154
 
        rev.parents = []
155
 
        precursor_id = branch.last_patch()
156
 
        if precursor_id:
157
 
            precursor_sha1 = branch.get_revision_sha1(precursor_id)
158
 
            rev.parents.append(RevisionReference(precursor_id, precursor_sha1))
159
 
        for merge_rev in pending_merges:
160
 
            rev.parents.append(RevisionReference(merge_rev))            
161
 
 
162
 
        rev_tmp = tempfile.TemporaryFile()
163
 
        pack_xml(rev, rev_tmp)
164
 
        rev_tmp.seek(0)
165
 
        branch.revision_store.add(rev_tmp, rev_id)
166
 
        mutter("new revision_id is {%s}" % rev_id)
167
 
 
168
 
        ## XXX: Everything up to here can simply be orphaned if we abort
169
 
        ## the commit; it will leave junk files behind but that doesn't
170
 
        ## matter.
171
 
 
172
 
        ## TODO: Read back the just-generated changeset, and make sure it
173
 
        ## applies and recreates the right state.
174
 
 
175
 
        ## TODO: Also calculate and store the inventory SHA1
176
 
        mutter("committing patch r%d" % (branch.revno() + 1))
177
 
 
178
 
        branch.append_revision(rev_id)
179
 
 
180
 
        branch.set_pending_merges([])
181
 
 
182
 
        if verbose:
183
 
            note("commited r%d" % branch.revno())
184
 
    finally:
185
 
        branch.unlock()
186
 
 
187
 
 
188
 
 
189
 
def _gen_revision_id(when):
190
 
    """Return new revision-id."""
191
 
    from binascii import hexlify
192
 
    from osutils import rand_bytes, compact_date, user_email
193
 
 
194
 
    s = '%s-%s-' % (user_email(), compact_date(when))
195
 
    s += hexlify(rand_bytes(8))
196
 
    return s
197
 
 
198
 
 
199
 
def _gather_commit(branch, work_tree, work_inv, basis_inv, specific_files,
200
 
                   verbose):
201
 
    """Build inventory preparatory to commit.
202
 
 
203
 
    Returns missing_ids, new_inv, any_changes.
204
 
 
205
 
    This adds any changed files into the text store, and sets their
206
 
    test-id, sha and size in the returned inventory appropriately.
207
 
 
208
 
    missing_ids
209
 
        Modified to hold a list of files that have been deleted from
210
 
        the working directory; these should be removed from the
211
 
        working inventory.
212
 
    """
213
 
    from bzrlib.inventory import Inventory
214
 
    from bzrlib.osutils import isdir, isfile, sha_string, quotefn, \
 
54
    import os, time, tempfile
 
55
 
 
56
    from inventory import Inventory
 
57
    from osutils import isdir, isfile, sha_string, quotefn, \
215
58
         local_time_offset, username, kind_marker, is_inside_any
216
59
    
217
 
    from bzrlib.branch import gen_file_id
218
 
    from bzrlib.errors import BzrError
219
 
    from bzrlib.revision import Revision
220
 
    from bzrlib.trace import mutter, note
221
 
 
222
 
    any_changes = False
223
 
    inv = Inventory(work_inv.root.file_id)
 
60
    from branch import gen_file_id
 
61
    from errors import BzrError
 
62
    from revision import Revision
 
63
    from trace import mutter, note
 
64
 
 
65
    branch._need_writelock()
 
66
 
 
67
    # First walk over the working inventory; and both update that
 
68
    # and also build a new revision inventory.  The revision
 
69
    # inventory needs to hold the text-id, sha1 and size of the
 
70
    # actual file versions committed in the revision.  (These are
 
71
    # not present in the working inventory.)  We also need to
 
72
    # detect missing/deleted files, and remove them from the
 
73
    # working inventory.
 
74
 
 
75
    work_tree = branch.working_tree()
 
76
    work_inv = work_tree.inventory
 
77
    inv = Inventory()
 
78
    basis = branch.basis_tree()
 
79
    basis_inv = basis.inventory
224
80
    missing_ids = []
225
 
    
 
81
 
 
82
    if verbose:
 
83
        note('looking for changes...')
 
84
        
226
85
    for path, entry in work_inv.iter_entries():
227
86
        ## TODO: Check that the file kind has not changed from the previous
228
87
        ## revision of this file (if any).
229
88
 
 
89
        entry = entry.copy()
 
90
 
230
91
        p = branch.abspath(path)
231
92
        file_id = entry.file_id
232
93
        mutter('commit prep file %s, id %r ' % (p, file_id))
233
94
 
234
95
        if specific_files and not is_inside_any(specific_files, path):
235
 
            mutter('  skipping file excluded from commit')
236
96
            if basis_inv.has_id(file_id):
237
97
                # carry over with previous state
238
98
                inv.add(basis_inv[file_id].copy())
244
104
        if not work_tree.has_id(file_id):
245
105
            if verbose:
246
106
                print('deleted %s%s' % (path, kind_marker(entry.kind)))
247
 
                any_changes = True
248
107
            mutter("    file is missing, removing from inventory")
249
108
            missing_ids.append(file_id)
250
109
            continue
251
110
 
252
 
        # this is present in the new inventory; may be new, modified or
253
 
        # unchanged.
254
 
        old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
255
 
        
256
 
        entry = entry.copy()
257
111
        inv.add(entry)
258
112
 
259
 
        if old_ie:
260
 
            old_kind = old_ie.kind
 
113
        if basis_inv.has_id(file_id):
 
114
            old_kind = basis_inv[file_id].kind
261
115
            if old_kind != entry.kind:
262
116
                raise BzrError("entry %r changed kind from %r to %r"
263
117
                        % (file_id, old_kind, entry.kind))
272
126
 
273
127
            new_sha1 = work_tree.get_file_sha1(file_id)
274
128
 
 
129
            old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
275
130
            if (old_ie
276
131
                and old_ie.text_sha1 == new_sha1):
277
132
                ## assert content == basis.get_file(file_id).read()
283
138
            else:
284
139
                content = file(p, 'rb').read()
285
140
 
286
 
                # calculate the sha again, just in case the file contents
287
 
                # changed since we updated the cache
288
141
                entry.text_sha1 = sha_string(content)
289
142
                entry.text_size = len(content)
290
143
 
291
144
                entry.text_id = gen_file_id(entry.name)
292
145
                branch.text_store.add(content, entry.text_id)
293
146
                mutter('    stored with text_id {%s}' % entry.text_id)
294
 
 
295
 
        if verbose:
296
 
            marked = path + kind_marker(entry.kind)
297
 
            if not old_ie:
298
 
                print 'added', marked
299
 
                any_changes = True
300
 
            elif old_ie == entry:
301
 
                pass                    # unchanged
302
 
            elif (old_ie.name == entry.name
303
 
                  and old_ie.parent_id == entry.parent_id):
304
 
                print 'modified', marked
305
 
                any_changes = True
306
 
            else:
307
 
                print 'renamed', marked
308
 
                any_changes = True
309
 
                        
310
 
    return missing_ids, inv, any_changes
 
147
                if verbose:
 
148
                    if not old_ie:
 
149
                        print('added %s' % path)
 
150
                    elif (old_ie.name == entry.name
 
151
                          and old_ie.parent_id == entry.parent_id):
 
152
                        print('modified %s' % path)
 
153
                    else:
 
154
                        print('renamed %s' % path)
 
155
 
 
156
 
 
157
    for file_id in missing_ids:
 
158
        # Any files that have been deleted are now removed from the
 
159
        # working inventory.  Files that were not selected for commit
 
160
        # are left as they were in the working inventory and ommitted
 
161
        # from the revision inventory.
 
162
        
 
163
        # have to do this later so we don't mess up the iterator.
 
164
        # since parents may be removed before their children we
 
165
        # have to test.
 
166
 
 
167
        # FIXME: There's probably a better way to do this; perhaps
 
168
        # the workingtree should know how to filter itbranch.
 
169
        if work_inv.has_id(file_id):
 
170
            del work_inv[file_id]
 
171
 
 
172
 
 
173
    if rev_id is None:
 
174
        rev_id = _gen_revision_id(time.time())
 
175
    inv_id = rev_id
 
176
 
 
177
    inv_tmp = tempfile.TemporaryFile()
 
178
    inv.write_xml(inv_tmp)
 
179
    inv_tmp.seek(0)
 
180
    branch.inventory_store.add(inv_tmp, inv_id)
 
181
    mutter('new inventory_id is {%s}' % inv_id)
 
182
 
 
183
    branch._write_inventory(work_inv)
 
184
 
 
185
    if timestamp == None:
 
186
        timestamp = time.time()
 
187
 
 
188
    if committer == None:
 
189
        committer = username()
 
190
 
 
191
    if timezone == None:
 
192
        timezone = local_time_offset()
 
193
 
 
194
    mutter("building commit log message")
 
195
    rev = Revision(timestamp=timestamp,
 
196
                   timezone=timezone,
 
197
                   committer=committer,
 
198
                   precursor = branch.last_patch(),
 
199
                   message = message,
 
200
                   inventory_id=inv_id,
 
201
                   revision_id=rev_id)
 
202
 
 
203
    rev_tmp = tempfile.TemporaryFile()
 
204
    rev.write_xml(rev_tmp)
 
205
    rev_tmp.seek(0)
 
206
    branch.revision_store.add(rev_tmp, rev_id)
 
207
    mutter("new revision_id is {%s}" % rev_id)
 
208
 
 
209
    ## XXX: Everything up to here can simply be orphaned if we abort
 
210
    ## the commit; it will leave junk files behind but that doesn't
 
211
    ## matter.
 
212
 
 
213
    ## TODO: Read back the just-generated changeset, and make sure it
 
214
    ## applies and recreates the right state.
 
215
 
 
216
    ## TODO: Also calculate and store the inventory SHA1
 
217
    mutter("committing patch r%d" % (branch.revno() + 1))
 
218
 
 
219
    branch.append_revision(rev_id)
 
220
 
 
221
    if verbose:
 
222
        note("commited r%d" % branch.revno())
 
223
 
 
224
 
 
225
 
 
226
def _gen_revision_id(when):
 
227
    """Return new revision-id."""
 
228
    from binascii import hexlify
 
229
    from osutils import rand_bytes, compact_date, user_email
 
230
 
 
231
    s = '%s-%s-' % (user_email(), compact_date(when))
 
232
    s += hexlify(rand_bytes(8))
 
233
    return s
311
234
 
312
235