~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Martin Pool
  • Date: 2005-06-01 04:09:38 UTC
  • Revision ID: mbp@sourcefrog.net-20050601040938-d905145b57ae017f
- unify two defintions of LockError

Show diffs side-by-side

added added

removed removed

Lines of Context:
22
22
           committer=None,
23
23
           verbose=True,
24
24
           specific_files=None,
25
 
           rev_id=None,
26
 
           allow_pointless=True):
 
25
           rev_id=None):
27
26
    """Commit working copy as a new revision.
28
27
 
29
28
    The basic approach is to add all the file texts into the
40
39
    be robust against files disappearing, moving, etc.  So the
41
40
    whole thing is a bit hard.
42
41
 
43
 
    This raises PointlessCommit if there are no changes, no new merges,
44
 
    and allow_pointless  is false.
45
 
 
46
42
    timestamp -- if not None, seconds-since-epoch for a
47
43
         postdated/predated commit.
48
44
 
57
53
        If null (default), a time/random revision id is generated.
58
54
    """
59
55
 
60
 
    import time, tempfile
 
56
    import os, time, tempfile
61
57
 
62
 
    from bzrlib.osutils import local_time_offset, username
63
 
    from bzrlib.branch import gen_file_id
64
 
    from bzrlib.errors import BzrError, PointlessCommit
65
 
    from bzrlib.revision import Revision, RevisionReference
66
 
    from bzrlib.trace import mutter, note
67
 
    from bzrlib.xml import serializer_v4
 
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
68
66
 
69
67
    branch.lock_write()
70
68
 
79
77
 
80
78
        work_tree = branch.working_tree()
81
79
        work_inv = work_tree.inventory
 
80
        inv = Inventory()
82
81
        basis = branch.basis_tree()
83
82
        basis_inv = basis.inventory
 
83
        missing_ids = []
84
84
 
85
85
        if verbose:
86
 
            # note('looking for changes...')
87
 
            # print 'looking for changes...'
88
 
            # disabled; should be done at a higher level
89
 
            pass
90
 
 
91
 
        pending_merges = branch.pending_merges()
92
 
 
93
 
        missing_ids, new_inv, any_changes = \
94
 
                     _gather_commit(branch,
95
 
                                    work_tree,
96
 
                                    work_inv,
97
 
                                    basis_inv,
98
 
                                    specific_files,
99
 
                                    verbose)
100
 
 
101
 
        if not (any_changes or allow_pointless or pending_merges):
102
 
            raise PointlessCommit()
 
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
 
103
161
 
104
162
        for file_id in missing_ids:
105
163
            # Any files that have been deleted are now removed from the
116
174
            if work_inv.has_id(file_id):
117
175
                del work_inv[file_id]
118
176
 
 
177
 
119
178
        if rev_id is None:
120
 
            rev_id = _gen_revision_id(branch, time.time())
 
179
            rev_id = _gen_revision_id(time.time())
121
180
        inv_id = rev_id
122
181
 
123
182
        inv_tmp = tempfile.TemporaryFile()
124
 
        
125
 
        serializer_v4.write_inventory(new_inv, inv_tmp)
 
183
        inv.write_xml(inv_tmp)
126
184
        inv_tmp.seek(0)
127
185
        branch.inventory_store.add(inv_tmp, inv_id)
128
186
        mutter('new inventory_id is {%s}' % inv_id)
129
187
 
130
 
        # We could also just sha hash the inv_tmp file
131
 
        # however, in the case that branch.inventory_store.add()
132
 
        # ever actually does anything special
133
 
        inv_sha1 = branch.get_inventory_sha1(inv_id)
134
 
 
135
188
        branch._write_inventory(work_inv)
136
189
 
137
190
        if timestamp == None:
138
191
            timestamp = time.time()
139
192
 
140
193
        if committer == None:
141
 
            committer = username(branch)
 
194
            committer = username()
142
195
 
143
196
        if timezone == None:
144
197
            timezone = local_time_offset()
147
200
        rev = Revision(timestamp=timestamp,
148
201
                       timezone=timezone,
149
202
                       committer=committer,
 
203
                       precursor = branch.last_patch(),
150
204
                       message = message,
151
205
                       inventory_id=inv_id,
152
 
                       inventory_sha1=inv_sha1,
153
206
                       revision_id=rev_id)
154
207
 
155
 
        rev.parents = []
156
 
        precursor_id = branch.last_patch()
157
 
        if precursor_id:
158
 
            precursor_sha1 = branch.get_revision_sha1(precursor_id)
159
 
            rev.parents.append(RevisionReference(precursor_id, precursor_sha1))
160
 
        for merge_rev in pending_merges:
161
 
            rev.parents.append(RevisionReference(merge_rev))            
162
 
 
163
208
        rev_tmp = tempfile.TemporaryFile()
164
 
        serializer_v4.write_revision(rev, rev_tmp)
 
209
        rev.write_xml(rev_tmp)
165
210
        rev_tmp.seek(0)
166
211
        branch.revision_store.add(rev_tmp, rev_id)
167
212
        mutter("new revision_id is {%s}" % rev_id)
178
223
 
179
224
        branch.append_revision(rev_id)
180
225
 
181
 
        branch.set_pending_merges([])
182
 
 
183
226
        if verbose:
184
 
            # disabled; should go through logging
185
 
            # note("commited r%d" % branch.revno())
186
 
            # print ("commited r%d" % branch.revno())
187
 
            pass
 
227
            note("commited r%d" % branch.revno())
188
228
    finally:
189
229
        branch.unlock()
190
230
 
191
231
 
192
232
 
193
 
def _gen_revision_id(branch, when):
 
233
def _gen_revision_id(when):
194
234
    """Return new revision-id."""
195
235
    from binascii import hexlify
196
 
    from bzrlib.osutils import rand_bytes, compact_date, user_email
 
236
    from osutils import rand_bytes, compact_date, user_email
197
237
 
198
 
    s = '%s-%s-' % (user_email(branch), compact_date(when))
 
238
    s = '%s-%s-' % (user_email(), compact_date(when))
199
239
    s += hexlify(rand_bytes(8))
200
240
    return s
201
241
 
202
242
 
203
 
def _gather_commit(branch, work_tree, work_inv, basis_inv, specific_files,
204
 
                   verbose):
205
 
    """Build inventory preparatory to commit.
206
 
 
207
 
    Returns missing_ids, new_inv, any_changes.
208
 
 
209
 
    This adds any changed files into the text store, and sets their
210
 
    test-id, sha and size in the returned inventory appropriately.
211
 
 
212
 
    missing_ids
213
 
        Modified to hold a list of files that have been deleted from
214
 
        the working directory; these should be removed from the
215
 
        working inventory.
216
 
    """
217
 
    from bzrlib.inventory import Inventory
218
 
    from bzrlib.osutils import isdir, isfile, sha_string, quotefn, \
219
 
         local_time_offset, username, kind_marker, is_inside_any
220
 
    
221
 
    from bzrlib.branch import gen_file_id
222
 
    from bzrlib.errors import BzrError
223
 
    from bzrlib.revision import Revision
224
 
    from bzrlib.trace import mutter, note
225
 
 
226
 
    any_changes = False
227
 
    inv = Inventory(work_inv.root.file_id)
228
 
    missing_ids = []
229
 
    
230
 
    for path, entry in work_inv.iter_entries():
231
 
        ## TODO: Check that the file kind has not changed from the previous
232
 
        ## revision of this file (if any).
233
 
 
234
 
        p = branch.abspath(path)
235
 
        file_id = entry.file_id
236
 
        mutter('commit prep file %s, id %r ' % (p, file_id))
237
 
 
238
 
        if specific_files and not is_inside_any(specific_files, path):
239
 
            mutter('  skipping file excluded from commit')
240
 
            if basis_inv.has_id(file_id):
241
 
                # carry over with previous state
242
 
                inv.add(basis_inv[file_id].copy())
243
 
            else:
244
 
                # omit this from committed inventory
245
 
                pass
246
 
            continue
247
 
 
248
 
        if not work_tree.has_id(file_id):
249
 
            if verbose:
250
 
                print('deleted %s%s' % (path, kind_marker(entry.kind)))
251
 
            any_changes = True
252
 
            mutter("    file is missing, removing from inventory")
253
 
            missing_ids.append(file_id)
254
 
            continue
255
 
 
256
 
        # this is present in the new inventory; may be new, modified or
257
 
        # unchanged.
258
 
        old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
259
 
        
260
 
        entry = entry.copy()
261
 
        inv.add(entry)
262
 
 
263
 
        if old_ie:
264
 
            old_kind = old_ie.kind
265
 
            if old_kind != entry.kind:
266
 
                raise BzrError("entry %r changed kind from %r to %r"
267
 
                        % (file_id, old_kind, entry.kind))
268
 
 
269
 
        if entry.kind == 'directory':
270
 
            if not isdir(p):
271
 
                raise BzrError("%s is entered as directory but not a directory"
272
 
                               % quotefn(p))
273
 
        elif entry.kind == 'file':
274
 
            if not isfile(p):
275
 
                raise BzrError("%s is entered as file but is not a file" % quotefn(p))
276
 
 
277
 
            new_sha1 = work_tree.get_file_sha1(file_id)
278
 
 
279
 
            if (old_ie
280
 
                and old_ie.text_sha1 == new_sha1):
281
 
                ## assert content == basis.get_file(file_id).read()
282
 
                entry.text_id = old_ie.text_id
283
 
                entry.text_sha1 = new_sha1
284
 
                entry.text_size = old_ie.text_size
285
 
                mutter('    unchanged from previous text_id {%s}' %
286
 
                       entry.text_id)
287
 
            else:
288
 
                content = file(p, 'rb').read()
289
 
 
290
 
                # calculate the sha again, just in case the file contents
291
 
                # changed since we updated the cache
292
 
                entry.text_sha1 = sha_string(content)
293
 
                entry.text_size = len(content)
294
 
 
295
 
                entry.text_id = gen_file_id(entry.name)
296
 
                branch.text_store.add(content, entry.text_id)
297
 
                mutter('    stored with text_id {%s}' % entry.text_id)
298
 
 
299
 
        if verbose:
300
 
            marked = path + kind_marker(entry.kind)
301
 
            if not old_ie:
302
 
                print 'added', marked
303
 
                any_changes = True
304
 
            elif old_ie == entry:
305
 
                pass                    # unchanged
306
 
            elif (old_ie.name == entry.name
307
 
                  and old_ie.parent_id == entry.parent_id):
308
 
                print 'modified', marked
309
 
                any_changes = True
310
 
            else:
311
 
                print 'renamed', marked
312
 
                any_changes = True
313
 
        elif old_ie != entry:
314
 
            any_changes = True
315
 
 
316
 
    return missing_ids, inv, any_changes
317
 
 
318