~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Martin Pool
  • Date: 2005-05-24 21:18:02 UTC
  • Revision ID: mbp@sourcefrog.net-20050524211802-87b146b2405e92d2
doc

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
61
 
 
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
68
 
 
69
 
    branch.lock_write()
70
 
 
71
 
    try:
72
 
        # First walk over the working inventory; and both update that
73
 
        # and also build a new revision inventory.  The revision
74
 
        # inventory needs to hold the text-id, sha1 and size of the
75
 
        # actual file versions committed in the revision.  (These are
76
 
        # not present in the working inventory.)  We also need to
77
 
        # detect missing/deleted files, and remove them from the
78
 
        # working inventory.
79
 
 
80
 
        work_tree = branch.working_tree()
81
 
        work_inv = work_tree.inventory
82
 
        basis = branch.basis_tree()
83
 
        basis_inv = basis.inventory
84
 
 
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()
103
 
 
104
 
        for file_id in missing_ids:
105
 
            # Any files that have been deleted are now removed from the
106
 
            # working inventory.  Files that were not selected for commit
107
 
            # are left as they were in the working inventory and ommitted
108
 
            # from the revision inventory.
109
 
 
110
 
            # have to do this later so we don't mess up the iterator.
111
 
            # since parents may be removed before their children we
112
 
            # have to test.
113
 
 
114
 
            # FIXME: There's probably a better way to do this; perhaps
115
 
            # the workingtree should know how to filter itbranch.
116
 
            if work_inv.has_id(file_id):
117
 
                del work_inv[file_id]
118
 
 
119
 
        if rev_id is None:
120
 
            rev_id = _gen_revision_id(branch, time.time())
121
 
        inv_id = rev_id
122
 
 
123
 
        inv_tmp = tempfile.TemporaryFile()
124
 
        
125
 
        serializer_v4.write_inventory(new_inv, inv_tmp)
126
 
        inv_tmp.seek(0)
127
 
        branch.inventory_store.add(inv_tmp, inv_id)
128
 
        mutter('new inventory_id is {%s}' % inv_id)
129
 
 
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
 
        branch._write_inventory(work_inv)
136
 
 
137
 
        if timestamp == None:
138
 
            timestamp = time.time()
139
 
 
140
 
        if committer == None:
141
 
            committer = username(branch)
142
 
 
143
 
        if timezone == None:
144
 
            timezone = local_time_offset()
145
 
 
146
 
        mutter("building commit log message")
147
 
        rev = Revision(timestamp=timestamp,
148
 
                       timezone=timezone,
149
 
                       committer=committer,
150
 
                       message = message,
151
 
                       inventory_id=inv_id,
152
 
                       inventory_sha1=inv_sha1,
153
 
                       revision_id=rev_id)
154
 
 
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
 
        rev_tmp = tempfile.TemporaryFile()
164
 
        serializer_v4.write_revision(rev, rev_tmp)
165
 
        rev_tmp.seek(0)
166
 
        branch.revision_store.add(rev_tmp, rev_id)
167
 
        mutter("new revision_id is {%s}" % rev_id)
168
 
 
169
 
        ## XXX: Everything up to here can simply be orphaned if we abort
170
 
        ## the commit; it will leave junk files behind but that doesn't
171
 
        ## matter.
172
 
 
173
 
        ## TODO: Read back the just-generated changeset, and make sure it
174
 
        ## applies and recreates the right state.
175
 
 
176
 
        ## TODO: Also calculate and store the inventory SHA1
177
 
        mutter("committing patch r%d" % (branch.revno() + 1))
178
 
 
179
 
        branch.append_revision(rev_id)
180
 
 
181
 
        branch.set_pending_merges([])
182
 
 
183
 
        if verbose:
184
 
            # disabled; should go through logging
185
 
            # note("commited r%d" % branch.revno())
186
 
            # print ("commited r%d" % branch.revno())
187
 
            pass
188
 
    finally:
189
 
        branch.unlock()
190
 
 
191
 
 
192
 
 
193
 
def _gen_revision_id(branch, when):
194
 
    """Return new revision-id."""
195
 
    from binascii import hexlify
196
 
    from bzrlib.osutils import rand_bytes, compact_date, user_email
197
 
 
198
 
    s = '%s-%s-' % (user_email(branch), compact_date(when))
199
 
    s += hexlify(rand_bytes(8))
200
 
    return s
201
 
 
202
 
 
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, \
 
56
    import os, time, tempfile
 
57
 
 
58
    from inventory import Inventory
 
59
    from osutils import isdir, isfile, sha_string, quotefn, \
219
60
         local_time_offset, username, kind_marker, is_inside_any
220
61
    
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)
 
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._need_writelock()
 
68
 
 
69
    # First walk over the working inventory; and both update that
 
70
    # and also build a new revision inventory.  The revision
 
71
    # inventory needs to hold the text-id, sha1 and size of the
 
72
    # actual file versions committed in the revision.  (These are
 
73
    # not present in the working inventory.)  We also need to
 
74
    # detect missing/deleted files, and remove them from the
 
75
    # working inventory.
 
76
 
 
77
    work_tree = branch.working_tree()
 
78
    work_inv = work_tree.inventory
 
79
    inv = Inventory()
 
80
    basis = branch.basis_tree()
 
81
    basis_inv = basis.inventory
228
82
    missing_ids = []
229
 
    
 
83
 
 
84
    if verbose:
 
85
        note('looking for changes...')
 
86
        
230
87
    for path, entry in work_inv.iter_entries():
231
88
        ## TODO: Check that the file kind has not changed from the previous
232
89
        ## revision of this file (if any).
233
90
 
 
91
        entry = entry.copy()
 
92
 
234
93
        p = branch.abspath(path)
235
94
        file_id = entry.file_id
236
95
        mutter('commit prep file %s, id %r ' % (p, file_id))
237
96
 
238
97
        if specific_files and not is_inside_any(specific_files, path):
239
 
            mutter('  skipping file excluded from commit')
240
98
            if basis_inv.has_id(file_id):
241
99
                # carry over with previous state
242
100
                inv.add(basis_inv[file_id].copy())
248
106
        if not work_tree.has_id(file_id):
249
107
            if verbose:
250
108
                print('deleted %s%s' % (path, kind_marker(entry.kind)))
251
 
                any_changes = True
252
109
            mutter("    file is missing, removing from inventory")
253
110
            missing_ids.append(file_id)
254
111
            continue
255
112
 
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
113
        inv.add(entry)
262
114
 
263
 
        if old_ie:
264
 
            old_kind = old_ie.kind
 
115
        if basis_inv.has_id(file_id):
 
116
            old_kind = basis_inv[file_id].kind
265
117
            if old_kind != entry.kind:
266
118
                raise BzrError("entry %r changed kind from %r to %r"
267
119
                        % (file_id, old_kind, entry.kind))
276
128
 
277
129
            new_sha1 = work_tree.get_file_sha1(file_id)
278
130
 
 
131
            old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
279
132
            if (old_ie
280
133
                and old_ie.text_sha1 == new_sha1):
281
134
                ## assert content == basis.get_file(file_id).read()
295
148
                entry.text_id = gen_file_id(entry.name)
296
149
                branch.text_store.add(content, entry.text_id)
297
150
                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
 
                        
314
 
    return missing_ids, inv, any_changes
 
151
                if verbose:
 
152
                    if not old_ie:
 
153
                        print('added %s' % path)
 
154
                    elif (old_ie.name == entry.name
 
155
                          and old_ie.parent_id == entry.parent_id):
 
156
                        print('modified %s' % path)
 
157
                    else:
 
158
                        print('renamed %s' % path)
 
159
 
 
160
 
 
161
    for file_id in missing_ids:
 
162
        # Any files that have been deleted are now removed from the
 
163
        # working inventory.  Files that were not selected for commit
 
164
        # are left as they were in the working inventory and ommitted
 
165
        # from the revision inventory.
 
166
        
 
167
        # have to do this later so we don't mess up the iterator.
 
168
        # since parents may be removed before their children we
 
169
        # have to test.
 
170
 
 
171
        # FIXME: There's probably a better way to do this; perhaps
 
172
        # the workingtree should know how to filter itbranch.
 
173
        if work_inv.has_id(file_id):
 
174
            del work_inv[file_id]
 
175
 
 
176
 
 
177
    if rev_id is None:
 
178
        rev_id = _gen_revision_id(time.time())
 
179
    inv_id = rev_id
 
180
 
 
181
    inv_tmp = tempfile.TemporaryFile()
 
182
    inv.write_xml(inv_tmp)
 
183
    inv_tmp.seek(0)
 
184
    branch.inventory_store.add(inv_tmp, inv_id)
 
185
    mutter('new inventory_id is {%s}' % inv_id)
 
186
 
 
187
    branch._write_inventory(work_inv)
 
188
 
 
189
    if timestamp == None:
 
190
        timestamp = time.time()
 
191
 
 
192
    if committer == None:
 
193
        committer = username()
 
194
 
 
195
    if timezone == None:
 
196
        timezone = local_time_offset()
 
197
 
 
198
    mutter("building commit log message")
 
199
    rev = Revision(timestamp=timestamp,
 
200
                   timezone=timezone,
 
201
                   committer=committer,
 
202
                   precursor = branch.last_patch(),
 
203
                   message = message,
 
204
                   inventory_id=inv_id,
 
205
                   revision_id=rev_id)
 
206
 
 
207
    rev_tmp = tempfile.TemporaryFile()
 
208
    rev.write_xml(rev_tmp)
 
209
    rev_tmp.seek(0)
 
210
    branch.revision_store.add(rev_tmp, rev_id)
 
211
    mutter("new revision_id is {%s}" % rev_id)
 
212
 
 
213
    ## XXX: Everything up to here can simply be orphaned if we abort
 
214
    ## the commit; it will leave junk files behind but that doesn't
 
215
    ## matter.
 
216
 
 
217
    ## TODO: Read back the just-generated changeset, and make sure it
 
218
    ## applies and recreates the right state.
 
219
 
 
220
    ## TODO: Also calculate and store the inventory SHA1
 
221
    mutter("committing patch r%d" % (branch.revno() + 1))
 
222
 
 
223
    branch.append_revision(rev_id)
 
224
 
 
225
    if verbose:
 
226
        note("commited r%d" % branch.revno())
 
227
 
 
228
 
 
229
 
 
230
def _gen_revision_id(when):
 
231
    """Return new revision-id."""
 
232
    from binascii import hexlify
 
233
    from osutils import rand_bytes, compact_date, user_email
 
234
 
 
235
    s = '%s-%s-' % (user_email(), compact_date(when))
 
236
    s += hexlify(rand_bytes(8))
 
237
    return s
315
238
 
316
239